diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 485040712f..56ef0ee482 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -1,6 +1,6 @@
 name: "CodeQL"
 
-on: [ pull_request ]
+on: [ pull_request, workflow_dispatch ]
 jobs:
   lint:
     name: CodeQL
@@ -13,8 +13,12 @@ jobs:
           fetch-depth: 2
 
       - run: git checkout HEAD^2
+        if: github.event_name == 'pull_request'
 
       - name: Run CodeQL
         run: |
-          docker run --rm -v $PWD:/app -w /app phpswoole/swoole:5.1.8-php8.3-alpine sh -c \
-          "composer install --profile --ignore-platform-reqs && composer check"
\ No newline at end of file
+          docker run --rm -v $PWD:/app -w /app php:8.4-cli-alpine sh -c \
+          "php -r \"copy('https://getcomposer.org/installer', '/tmp/composer-setup.php');\" && \
+           php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer && \
+           composer install --profile --ignore-platform-reqs && \
+           composer check"
diff --git a/.github/workflows/linter.yml b/.github/workflows/linter.yml
index ca49ca5c60..599a64dc9f 100644
--- a/.github/workflows/linter.yml
+++ b/.github/workflows/linter.yml
@@ -1,6 +1,6 @@
 name: "Linter"
 
-on: [ pull_request ]
+on: [ pull_request, workflow_dispatch ]
 jobs:
   lint:
     name: Linter
@@ -13,8 +13,10 @@ jobs:
           fetch-depth: 2
 
       - run: git checkout HEAD^2
+        if: github.event_name == 'pull_request'
 
       - name: Run Linter
         run: |
           docker run --rm -v $PWD:/app -w /app phpswoole/swoole:5.1.8-php8.3-alpine sh -c \
-          "composer install --profile --ignore-platform-reqs && composer lint"
+          "composer install --profile --ignore-platform-reqs && \
+           composer lint"
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 318304d9d3..283f831c0b 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -6,9 +6,9 @@ concurrency:
 
 env:
   IMAGE: databases-dev
-  CACHE_KEY: databases-dev-${{ github.event.pull_request.head.sha }}
+  CACHE_KEY: databases-dev-${{ github.event.pull_request.head.sha || github.sha }}
 
-on: [pull_request]
+on: [pull_request, workflow_dispatch]
 
 jobs:
   setup:
@@ -25,6 +25,7 @@ jobs:
         uses: docker/build-push-action@1104d471370f9806843c095c1db02b5a90c5f8b6 # v3.3.1
         with:
           context: .
+          file: Dockerfile
           push: false
           tags: ${{ env.IMAGE }}
           load: true
@@ -60,34 +61,48 @@ jobs:
           docker compose up -d --wait
 
       - name: Run Unit Tests
-        run: docker compose exec tests vendor/bin/phpunit /usr/src/code/tests/unit
+        run: docker compose exec -e XDEBUG_MODE=off tests vendor/bin/paratest --configuration phpunit.xml --functional --processes 4 /usr/src/code/tests/unit
 
   adapter_test:
-    name: Adapter Tests
+    name: "Adapter Tests (${{ matrix.adapter }})"
     runs-on: ubuntu-latest
     needs: setup
     strategy:
       fail-fast: false
       matrix:
-        adapter:
-          [
-            MongoDB,
-            MariaDB,
-            MySQL,
-            Postgres,
-            SQLite,
-            Memory,
-            Mirror,
-            Pool,
-            Redis,
-            SharedTables/MongoDB,
-            SharedTables/MariaDB,
-            SharedTables/MySQL,
-            SharedTables/Postgres,
-            SharedTables/SQLite,
-            SharedTables/Redis,
-            Schemaless/MongoDB,
-          ]
+        include:
+          - adapter: MongoDB
+            profiles: "--profile mongo"
+          - adapter: MariaDB
+            profiles: "--profile mariadb"
+          - adapter: MySQL
+            profiles: "--profile mysql"
+          - adapter: Postgres
+            profiles: "--profile postgres"
+          - adapter: SQLite
+            profiles: ""
+          - adapter: Memory
+            profiles: ""
+          - adapter: Mirror
+            profiles: "--profile mariadb --profile mariadb-mirror --profile redis-mirror"
+          - adapter: Pool
+            profiles: "--profile mysql"
+          - adapter: Redis
+            profiles: ""
+          - adapter: SharedTables/MongoDB
+            profiles: "--profile mongo"
+          - adapter: SharedTables/MariaDB
+            profiles: "--profile mariadb"
+          - adapter: SharedTables/MySQL
+            profiles: "--profile mysql"
+          - adapter: SharedTables/Postgres
+            profiles: "--profile postgres"
+          - adapter: SharedTables/SQLite
+            profiles: ""
+          - adapter: SharedTables/Redis
+            profiles: ""
+          - adapter: Schemaless/MongoDB
+            profiles: "--profile mongo"
 
     steps:
       - name: checkout
@@ -103,7 +118,7 @@ jobs:
       - name: Load and Start Services
         run: |
           docker load --input /tmp/${{ env.IMAGE }}.tar
-          docker compose up -d --wait
+          docker compose ${{ matrix.profiles }} up -d --wait
 
       - name: Run Tests
-        run: docker compose exec -T tests vendor/bin/phpunit /usr/src/code/tests/e2e/Adapter/${{matrix.adapter}}Test.php --debug
+        run: docker compose exec -T -e XDEBUG_MODE=off tests vendor/bin/paratest --configuration phpunit.xml --functional --processes 4 /usr/src/code/tests/e2e/Adapter/${{matrix.adapter}}Test.php
diff --git a/.gitignore b/.gitignore
index 46daf3d316..1d4d5f1eeb 100755
--- a/.gitignore
+++ b/.gitignore
@@ -12,3 +12,4 @@ Makefile
 .envrc
 .vscode
 tmp
+*.sql
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000000..0a7d213132
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,118 @@
+# Utopia Database
+
+PHP database abstraction library with a unified API across MariaDB 10.5, MySQL 8.0, PostgreSQL 13+, SQLite 3.38+, and MongoDB.
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| `composer build` | Build Docker containers |
+| `composer start` | Start all database containers in background |
+| `composer test` | Run tests in Docker (ParaTest, 4 parallel processes) |
+| `composer lint` | Check formatting (Pint, PSR-12) |
+| `composer format` | Auto-format code |
+| `composer check` | Static analysis (PHPStan, max level, 2GB) |
+| `composer coverage` | Check test coverage (90% minimum required) |
+
+Run a single test:
+```bash
+docker compose exec tests vendor/bin/phpunit --configuration phpunit.xml tests/e2e/Adapter/MariaDBTest.php
+docker compose exec tests vendor/bin/phpunit --configuration phpunit.xml tests/unit/Validator/SomeTest.php
+```
+
+## Stack
+
+- PHP 8.4+, Docker Compose for test databases
+- ParaTest (parallel PHPUnit), Pint (PSR-12), PHPStan (max level)
+- Test databases: MariaDB 10.11, MySQL 8.0.43, PostgreSQL 16, SQLite, MongoDB 8.0.14
+- Redis 8.2.1 for caching tests
+
+## Project layout
+
+- **src/Database/** -- core library (PSR-4 namespace `Utopia\Database\`)
+  - `Database.php` -- main API class (uses trait composition for organization)
+  - `Adapter.php` -- base adapter class all engines extend
+  - `Adapter/` -- engine implementations: MariaDB, MySQL, Postgres, SQLite, Mongo, Pool, ReadWritePool
+  - `Adapter/SQL.php` -- shared SQL adapter base (MariaDB, MySQL, Postgres, SQLite extend this)
+  - `Adapter/Feature/` -- capability interfaces for adapter features
+  - `Document.php` -- JSON document model (extends ArrayObject)
+  - `Mirror.php` -- database mirroring/replication
+  - `Query.php` -- query builder extension
+  - `Attribute.php` -- attribute type definitions
+  - `Index.php` -- index management
+  - `Relationship.php` -- relationship definitions
+  - `Traits/` -- Database.php composition: Async, Attributes, Collections, Databases, Documents, Entities, Indexes, Relationships, Transactions
+  - `Hook/` -- event hooks and interceptors: Lifecycle, Permissions, Relationships, TenantFilter, Transform, Read, Write, WriteContext, Interceptor, Decorator, PermissionFilter, Mongo/PermissionFilter, Mongo/TenantFilter, Tenancy
+  - `Event/` -- Domain, DispatcherHook, plus Collection/{Created,Deleted} and Document/{Created,Deleted,Updated}
+  - `ORM/` -- EntityManager, EntityMapper, EntityMetadata, EntityState, IdentityMap, MetadataFactory, UnitOfWork, ColumnMapping, EmbeddableMapping, RelationshipMapping, plus `Mapping/` (Entity, Column, Id, HasMany, HasOne, BelongsTo, Embedded, Permissions, Tenant, Pre/{Persist,Remove,Update}, Post/{Persist,Remove,Update}, etc.)
+  - `Schema/` -- Introspector, Diff, Change, ChangeType, DiffResult
+  - `Validator/` -- input validators (19 top-level + subdirectories)
+  - `Helpers/` -- ID, Permission, Role utilities
+  - `Exception/` -- 18 exception types (Authorization, Duplicate, Limit, Query, Timeout, etc.)
+
+- **tests/unit/** -- unit tests for validators, helpers, etc.
+- **tests/e2e/Adapter/** -- E2E tests against real databases
+  - `Base.php` -- abstract test class all adapter tests extend
+  - `Scopes/` -- test trait mixins (DocumentTests, AttributeTests, CollectionTests, PermissionTests, RelationshipTests, SpatialTests, VectorTests, etc.)
+  - Each adapter test (MariaDBTest, PostgresTest, etc.) extends Base and gets all scope traits
+
+## Key patterns
+
+**Multi-adapter:** Single `Database` class with engine-specific `Adapter` implementations. SQL adapters share `SQL.php` base; MongoDB has its own.
+
+**Document model:** Documents are ArrayObject subclasses with reserved attributes: `$id`, `$sequence`, `$createdAt`, `$updatedAt`, `$collection`, `$permissions`.
+
+**Hook system:** Pluggable hooks for permissions, relationships, tenancy filtering, and lifecycle events. Hooks registered on the Database instance.
+
+**Custom document types:**
+```php
+$database->setDocumentType('users', User::class);
+$user = $database->getDocument('users', 'id123'); // Returns User instance
+```
+
+**Trait composition:** `Database.php` splits its API across 9 traits in `Traits/` for organization. Each trait groups related operations (documents, attributes, indexes, entities, etc.).
+
+**Connection pooling:** `Pool` adapter wraps multiple connections. `ReadWritePool` distributes reads and writes to separate pools.
+
+**Query builder:** Integrates with `utopia-php/query`. Queries grouped by type: filters, selections, aggregations, ordering, pagination.
+
+## Testing patterns
+
+- E2E tests extend `Base.php` which provides setUp/tearDown for real database connections
+- Test functionality split into trait mixins in `Scopes/` -- each adapter test includes all relevant traits
+- Unit tests in `tests/unit/` for validators and helpers
+- Tests check for `ext-swoole` and skip if missing
+
+## Docker services
+
+```bash
+composer build && composer start   # Start all databases
+```
+
+Services (activated via Docker Compose profiles):
+- `mariadb` (port 3306), `mysql` (port 3307), `postgres` (port 5432), `mongo` (port 27017)
+- `redis` (port 6379) for caching
+- Mirror variants for replication tests
+- `adminer` (port 8700, debug profile) for database UI
+
+## Load testing
+
+```bash
+bin/load --adapter=mariadb      # Populate test data
+bin/index --adapter=mariadb     # Create indexes
+bin/query --adapter=mariadb     # Run queries
+bin/compare                     # Visualize at localhost:8708
+```
+
+## Conventions
+
+- PSR-12 via Pint, PSR-4 autoloading
+- One class per file, filename matches class name
+- Full type hints on all parameters and returns, readonly properties for immutable data
+- Imports: alphabetical, single per statement, grouped by const/class/function
+- Constants: UPPER_SNAKE_CASE
+- Methods: camelCase with verb prefixes (get*, set*, create*, update*, delete*)
+
+## Cross-repo context
+
+Changes to the Query builder or Adapter interface may break appwrite. Run `composer test` in both repos after adapter changes.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..43c994c2d3
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/Dockerfile b/Dockerfile
index d43c2a167d..15db406a18 100755
--- a/Dockerfile
+++ b/Dockerfile
@@ -115,8 +115,6 @@ RUN EXT_DIR=$(php-config --extension-dir) \
 RUN echo extension=redis.so >> /usr/local/etc/php/conf.d/redis.ini
 RUN echo extension=swoole.so >> /usr/local/etc/php/conf.d/swoole.ini
 RUN echo extension=pcov.so >> /usr/local/etc/php/conf.d/pcov.ini
-RUN echo extension=xdebug.so >> /usr/local/etc/php/conf.d/xdebug.ini
-
 RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
 
 RUN echo "opcache.enable_cli=1" >> $PHP_INI_DIR/php.ini
@@ -131,6 +129,6 @@ COPY ./dev /usr/src/code/dev
 RUN if [ "$DEBUG" = "true" ]; then cp /usr/src/code/dev/xdebug.ini /usr/local/etc/php/conf.d/xdebug.ini; fi
 RUN if [ "$DEBUG" = "true" ]; then mkdir -p /tmp/xdebug; fi
 RUN if [ "$DEBUG" = "false" ]; then rm -rf /usr/src/code/dev; fi
-RUN if [ "$DEBUG" = "false" ]; then rm -f $(php-config --extension-dir)/xdebug.so; fi
+RUN if [ "$DEBUG" = "false" ]; then rm -f /usr/local/etc/php/conf.d/xdebug.ini; fi
 
 CMD [ "tail", "-f", "/dev/null" ]
diff --git a/README.md b/README.md
index 309966b1d3..fdee5b4d5d 100644
--- a/README.md
+++ b/README.md
@@ -355,58 +355,23 @@ $database->getKeywords();
 ### Collection Methods
 
 ```php
-// Creates two new collection named '$namespace_$collectionName' with attribute names '_id', '_uid', '_createdAt', '_updatedAt', '_permissions' 
+// Creates two new collection named '$namespace_$collectionName' with attribute names '_id', '_uid', '_createdAt', '_updatedAt', '_permissions'
 // The second collection is named '$namespace_$collectionName_perms' with attribute names '_id', '_type', '_permission', '_document'
-$database->createCollection(
-    id: 'users'
-);
-
-// Create collection with attributes and indexes
-$attributes = [
-     new Document([
-         '$id' => ID::unique(),
-         '$permissions' => [
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-         ],
-         'name' => 'Jhon', 
-         'age'  =>  20
-     ]),
-     new Document([
-         '$id' => ID::unique(),
-         '$permissions' => [
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-         ],
-         'name' => 'Doe', 
-         'age'  =>  34
-     ]),
-]
-
-$indexes = [
-     new Document([
-            '$id' => ID::unique(),
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['name'],
-            'lengths' => [256],
-            'orders' => ['ASC'],
-        ]),
-     new Document([
-            '$id' => ID::unique(),
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['name', 'age'],
-            'lengths' => [128, 128],
-            'orders' => ['ASC'],
-        ])
-];
+$database->createCollection(new Collection(
+    id: 'users',
+));
 
-$database->createCollection(
-    id: 'users', 
-    attributes: $attributes, 
-    indexes: $indexes
-);
+$database->createCollection(new Collection(
+    id: 'users',
+    attributes: [
+        Attribute::string(key: 'name', size: 256),
+        Attribute::integer(key: 'age'),
+    ],
+    indexes: [
+        Index::key(key: 'idx_name', attributes: ['name'], lengths: [256], orders: ['ASC']),
+        Index::key(key: 'idx_name_age', attributes: ['name', 'age'], lengths: [128, 128], orders: ['ASC']),
+    ],
+));
 
 // Update Collection Permissions
 $database->updateCollection(
@@ -633,22 +598,22 @@ $database->createRelationship(
 ); 
 
 // Relationship onDelete types
-Database::RELATION_MUTATE_CASCADE, 
-Database::RELATION_MUTATE_SET_NULL,
-Database::RELATION_MUTATE_RESTRICT,
+ForeignKeyAction::Cascade->value,
+ForeignKeyAction::SetNull->value,
+ForeignKeyAction::Restrict->value,
 
 // Update the relationship with the default reference attributes
 $database->updateRelationship(
     collection: 'movies', 
     id: 'users', 
-    onDelete: Database::RELATION_MUTATE_CASCADE
+    onDelete: ForeignKeyAction::Cascade->value
 ); 
 
 // Update the relationship with custom reference attributes
 $database->updateRelationship(
     collection: 'movies', 
     id: 'users', 
-    onDelete: Database::RELATION_MUTATE_CASCADE, 
+    onDelete: ForeignKeyAction::Cascade->value,
     newKey: 'movies_id', 
     newTwoWayKey: 'users_id', 
     twoWay: true
@@ -755,25 +720,25 @@ $database->decreaseDocumentAttribute(
 // Update the value of an attribute in a document
 
 // Set types
-Document::SET_TYPE_ASSIGN, // Assign the new value directly
-Document::SET_TYPE_APPEND, // Append the new value to end of the array
-Document::SET_TYPE_PREPEND // Prepend the new value to start of the array
+SetType::Assign, // Assign the new value directly
+SetType::Append, // Append the new value to end of the array
+SetType::Prepend // Prepend the new value to start of the array
 Note: Using append/prepend with an attribute which is not an array, it will be set to an array containing the new value.
 
 $document->setAttribute(key: 'name', 'Chris Smoove')
-         ->setAttribute(key: 'age', 33, Document::SET_TYPE_ASSIGN);
+         ->setAttribute(key: 'age', 33, SetType::Assign);
 
 $database->updateDocument(
-    collection: 'users', 
-    id: $document->getId(), 
+    collection: 'users',
+    id: $document->getId(),
     document: $document
-);         
+);
 
 // Update the permissions of a document
-$document->setAttribute('$permissions', Permission::read(Role::any()), Document::SET_TYPE_APPEND)
-         ->setAttribute('$permissions', Permission::create(Role::any()), Document::SET_TYPE_APPEND)
-         ->setAttribute('$permissions', Permission::update(Role::any()), Document::SET_TYPE_APPEND)
-         ->setAttribute('$permissions', Permission::delete(Role::any()), Document::SET_TYPE_APPEND)
+$document->setAttribute('$permissions', Permission::read(Role::any()), SetType::Append)
+         ->setAttribute('$permissions', Permission::create(Role::any()), SetType::Append)
+         ->setAttribute('$permissions', Permission::update(Role::any()), SetType::Append)
+         ->setAttribute('$permissions', Permission::delete(Role::any()), SetType::Append)
 
 $database->updateDocument(
     collection: 'users', 
diff --git a/bin/cli.php b/bin/cli.php
index 77f462eabe..7054c3e641 100644
--- a/bin/cli.php
+++ b/bin/cli.php
@@ -2,13 +2,68 @@
 
 require_once '/usr/src/code/vendor/autoload.php';
 
+use Utopia\Cache\Adapter\None as NoCache;
+use Utopia\Cache\Cache;
 use Utopia\CLI\CLI;
 use Utopia\Console;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\MySQL;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Database;
+use Utopia\Database\PDO;
+use Utopia\DI\Dependency;
 
 ini_set('memory_limit', '-1');
 
 $cli = new CLI();
 
+$database = new Dependency();
+$database
+    ->setName('database')
+    ->setCallback(static fn (): callable => static function (string $adapter, string $name, string $namespace, bool $sharedTables): Database {
+        $adapters = [
+            'mariadb' => [
+                'dsn' => 'mysql:host=mariadb;port=3306;charset=utf8mb4',
+                'user' => 'root',
+                'password' => 'password',
+                'class' => MariaDB::class,
+            ],
+            'mysql' => [
+                'dsn' => 'mysql:host=mysql;port=3307;charset=utf8mb4',
+                'user' => 'root',
+                'password' => 'password',
+                'class' => MySQL::class,
+            ],
+            'postgres' => [
+                'dsn' => 'pgsql:host=postgres;port=5432',
+                'user' => 'postgres',
+                'password' => 'password',
+                'class' => Postgres::class,
+            ],
+        ];
+
+        $config = $adapters[$adapter] ?? throw new RuntimeException("Adapter '{$adapter}' not supported");
+        $class = $config['class'];
+        $pdo = new PDO(
+            $config['dsn'],
+            $config['user'],
+            $config['password'],
+            $class::getPDOAttributes(),
+        );
+
+        $database = (new Database(new $class($pdo), new Cache(new NoCache())))
+            ->setDatabase($name)
+            ->setNamespace($namespace)
+            ->setSharedTables($sharedTables);
+
+        if (! $database->exists()) {
+            $database->create();
+        }
+
+        return $database;
+    });
+$cli->setResource($database);
+
 include 'tasks/load.php';
 include 'tasks/index.php';
 include 'tasks/query.php';
diff --git a/bin/tasks/index.php b/bin/tasks/index.php
index 256f23ce10..d1cd493921 100644
--- a/bin/tasks/index.php
+++ b/bin/tasks/index.php
@@ -13,7 +13,9 @@
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
 use Utopia\Database\Database;
+use Utopia\Database\Index;
 use Utopia\Database\PDO;
+use Utopia\Query\Schema\Order;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Text;
 
@@ -61,8 +63,9 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
@@ -82,31 +85,31 @@
 
         Console::info("Creating key index 'createdGenre' on 'articles' for created > '2010-01-01 05:00:00' and genre = 'travel'");
         $start = microtime(true);
-        $database->createIndex('articles', 'createdGenre', Database::INDEX_KEY, ['created', 'genre'], [], [Database::ORDER_DESC, Database::ORDER_DESC]);
+        $database->createIndex('articles', Index::key(key: 'createdGenre', attributes: ['created', 'genre'], orders: [Order::Desc, Order::Desc]));
         $time = microtime(true) - $start;
         Console::success("Index 'createdGenre' created in {$time} seconds");
 
         Console::info("Creating key index 'genre' on 'articles' for genres: fashion, finance, sports");
         $start = microtime(true);
-        $database->createIndex('articles', 'genre', Database::INDEX_KEY, ['genre'], [], [Database::ORDER_ASC]);
+        $database->createIndex('articles', Index::key(key: 'genre', attributes: ['genre'], orders: [Order::Asc]));
         $time = microtime(true) - $start;
         Console::success("Index 'genre' created in {$time} seconds");
 
         Console::info("Creating key index 'views' on 'articles' for views > 100000");
         $start = microtime(true);
-        $database->createIndex('articles', 'views', Database::INDEX_KEY, ['views'], [], [Database::ORDER_DESC]);
+        $database->createIndex('articles', Index::key(key: 'views', attributes: ['views'], orders: [Order::Desc]));
         $time = microtime(true) - $start;
         Console::success("Index 'views' created in {$time} seconds");
 
         Console::info("Creating fulltext index 'fulltextsearch' on 'articles' for search term 'Alice'");
         $start = microtime(true);
-        $database->createIndex('articles', 'fulltextsearch', Database::INDEX_FULLTEXT, ['text']);
+        $database->createIndex('articles', Index::fullText(key: 'fulltextsearch', attributes: ['text']));
         $time = microtime(true) - $start;
         Console::success("Index 'fulltextsearch' created in {$time} seconds");
 
         Console::info("Creating key index 'tags' on 'articles' for tags containing 'tag1'");
         $start = microtime(true);
-        $database->createIndex('articles', 'tags', Database::INDEX_KEY, ['tags']);
+        $database->createIndex('articles', Index::key(key: 'tags', attributes: ['tags']));
         $time = microtime(true) - $start;
         Console::success("Index 'tags' created in {$time} seconds");
     });
diff --git a/bin/tasks/load.php b/bin/tasks/load.php
index 17206de1f1..6ede25950b 100644
--- a/bin/tasks/load.php
+++ b/bin/tasks/load.php
@@ -10,11 +10,14 @@
 use Utopia\Database\Adapter\MariaDB;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\PDO;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Integer;
@@ -25,7 +28,6 @@
 $genresPool = ['fashion', 'food', 'travel', 'music', 'lifestyle', 'fitness', 'diy', 'sports', 'finance'];
 $tagsPool = ['short', 'quick', 'easy', 'medium', 'hard'];
 
-
 /**
  * @Example
  * docker compose exec tests bin/load --adapter=mariadb --limit=1000
@@ -35,11 +37,10 @@
     ->desc('Load database with mock data for testing')
     ->param('adapter', '', new Text(0), 'Database adapter')
     ->param('limit', 0, new Integer(true), 'Total number of records to add to database')
-    ->param('name', 'myapp_' . uniqid(), new Text(0), 'Name of created database.', true)
+    ->param('name', 'myapp_'.uniqid(), new Text(0), 'Name of created database.', true)
     ->param('sharedTables', false, new Boolean(true), 'Whether to use shared tables', true)
     ->action(function (string $adapter, int $limit, string $name, bool $sharedTables) {
 
-
         $createSchema = function (Database $database): void {
             if ($database->exists($database->getDatabase())) {
                 $database->delete($database->getDatabase());
@@ -47,28 +48,27 @@
             $database->getAuthorization()->addRole(Role::any()->toString());
             $database->create();
 
-            $database->createCollection('articles', permissions: [
+            $database->createCollection(new Collection(id: 'articles', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
-            ]);
-
-            $database->createAttribute('articles', 'author', Database::VAR_STRING, 256, true);
-            $database->createAttribute('articles', 'created', Database::VAR_DATETIME, 0, true, filters: ['datetime']);
-            $database->createAttribute('articles', 'text', Database::VAR_STRING, 5000, true);
-            $database->createAttribute('articles', 'genre', Database::VAR_STRING, 256, true);
-            $database->createAttribute('articles', 'views', Database::VAR_INTEGER, 0, true);
-            $database->createAttribute('articles', 'tags', Database::VAR_STRING, 0, true, array: true);
-            $database->createIndex('articles', 'text', Database::INDEX_FULLTEXT, ['text']);
+            ]));
+
+            $database->createAttribute('articles', Attribute::string(key: 'author', size: 256, required: true));
+            $database->createAttribute('articles', Attribute::datetime(key: 'created', size: 0, required: true, filters: ['datetime']));
+            $database->createAttribute('articles', Attribute::string(key: 'text', size: 5000, required: true));
+            $database->createAttribute('articles', Attribute::string(key: 'genre', size: 256, required: true));
+            $database->createAttribute('articles', Attribute::integer(key: 'views', size: 0, required: true));
+            $database->createAttribute('articles', Attribute::string(key: 'tags', size: 0, required: true, array: true));
+            $database->createIndex('articles', Index::fullText(key: 'text', attributes: ['text']));
         };
 
-
         $start = null;
         $namespace = '_ns';
         $cache = new Cache(new NoCache());
 
         Console::info("Filling {$adapter} with {$limit} records: {$name}");
 
-        //Runtime::enableCoroutine();
+        // Runtime::enableCoroutine();
 
         $dbAdapters = [
             'mariadb' => [
@@ -103,15 +103,16 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
         $cfg = $dbAdapters[$adapter];
         $dsn = ($cfg['dsn'])($cfg['host'], $cfg['port']);
 
-        //Co\run(function () use (&$start, $limit, $name, $sharedTables, $namespace, $cache, $cfg) {
+        // Co\run(function () use (&$start, $limit, $name, $sharedTables, $namespace, $cache, $cfg) {
         $pdo = new PDO(
             $dsn,
             $cfg['user'],
@@ -132,7 +133,7 @@
                 ->withHost($cfg['host'])
                 ->withPort($cfg['port'])
                 ->withDbName($name)
-                //->withCharset('utf8mb4')
+                // ->withCharset('utf8mb4')
                 ->withUsername($cfg['user'])
                 ->withPassword($cfg['pass']),
             128
@@ -141,9 +142,9 @@
         $start = \microtime(true);
 
         for ($i = 0; $i < $limit / 1000; $i++) {
-            //\go(function () use ($cfg, $pool, $name, $namespace, $sharedTables, $cache) {
+            // \go(function () use ($cfg, $pool, $name, $namespace, $sharedTables, $cache) {
             try {
-                //$pdo = $pool->get();
+                // $pdo = $pool->get();
 
                 $database = (new Database(new ($cfg['adapter'])($pdo), $cache))
                     ->setDatabase($name)
@@ -151,19 +152,17 @@
                     ->setSharedTables($sharedTables);
 
                 createDocuments($database);
-                //$pool->put($pdo);
+                // $pool->put($pdo);
             } catch (\Throwable $error) {
-                Console::error('Coroutine error: ' . $error->getMessage());
+                Console::error('Coroutine error: '.$error->getMessage());
             }
-            //});
+            // });
         }
 
         $time = microtime(true) - $start;
         Console::success("Completed in {$time} seconds");
     });
 
-
-
 function createDocuments(Database $database): void
 {
     global $namesPool, $genresPool, $tagsPool;
@@ -176,16 +175,16 @@ function createDocuments(Database $database): void
         $bytes = \random_bytes(intdiv($length + 1, 2));
         $text = \substr(\bin2hex($bytes), 0, $length);
         $tagCount = \mt_rand(1, count($tagsPool));
-        $tagKeys = (array)\array_rand($tagsPool, $tagCount);
+        $tagKeys = (array) \array_rand($tagsPool, $tagCount);
         $tags = \array_map(fn ($k) => $tagsPool[$k], $tagKeys);
 
         $documents[] = new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
-                ...array_map(fn () => Permission::read(Role::user(mt_rand(0, 999999999))), range(1, 4)),
-                ...array_map(fn () => Permission::create(Role::user(mt_rand(0, 999999999))), range(1, 3)),
-                ...array_map(fn () => Permission::update(Role::user(mt_rand(0, 999999999))), range(1, 3)),
-                ...array_map(fn () => Permission::delete(Role::user(mt_rand(0, 999999999))), range(1, 3)),
+                ...array_map(fn () => Permission::read(Role::user((string) mt_rand(0, 999999999))), range(1, 4)),
+                ...array_map(fn () => Permission::create(Role::user((string) mt_rand(0, 999999999))), range(1, 3)),
+                ...array_map(fn () => Permission::update(Role::user((string) mt_rand(0, 999999999))), range(1, 3)),
+                ...array_map(fn () => Permission::delete(Role::user((string) mt_rand(0, 999999999))), range(1, 3)),
             ],
             'author' => $namesPool[\array_rand($namesPool)],
             'created' => DateTime::now(),
diff --git a/bin/tasks/operators.php b/bin/tasks/operators.php
index d351b0ca13..19546be198 100644
--- a/bin/tasks/operators.php
+++ b/bin/tasks/operators.php
@@ -14,16 +14,18 @@
  * The --seed parameter allows you to pre-populate the collection with a specified
  * number of documents to test how operators perform with varying amounts of existing data.
  */
-
 global $cli;
 
 use Utopia\Cache\Adapter\None as NoCache;
 use Utopia\Cache\Cache;
 use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Adapter\MariaDB;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
 use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -41,14 +43,14 @@
     ->param('adapter', '', new Text(0), 'Database adapter (mariadb, postgres, sqlite)')
     ->param('iterations', 1000, new Integer(true), 'Number of iterations per test', true)
     ->param('seed', 0, new Integer(true), 'Number of documents to pre-seed the collection with', true)
-    ->param('name', 'operator_benchmark_' . uniqid(), new Text(0), 'Name of test database', true)
+    ->param('name', 'operator_benchmark_'.uniqid(), new Text(0), 'Name of test database', true)
     ->action(function (string $adapter, int $iterations, int $seed, string $name) {
         $namespace = '_ns';
         $cache = new Cache(new NoCache());
 
-        Console::info("=============================================================");
-        Console::info("  OPERATOR PERFORMANCE BENCHMARK");
-        Console::info("=============================================================");
+        Console::info('=============================================================');
+        Console::info('  OPERATOR PERFORMANCE BENCHMARK');
+        Console::info('=============================================================');
         Console::info("Adapter: {$adapter}");
         Console::info("Iterations: {$iterations}");
         Console::info("Seed Documents: {$seed}");
@@ -91,14 +93,15 @@
                 'port' => 0,
                 'user' => '',
                 'pass' => '',
-                'dsn' => static fn (string $host, int $port) => "sqlite::memory:",
+                'dsn' => static fn (string $host, int $port) => 'sqlite::memory:',
                 'adapter' => SQLite::class,
                 'attrs' => [],
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported. Available: mariadb, postgres, sqlite");
+
             return;
         }
 
@@ -128,8 +131,9 @@
             Console::success("\nBenchmark completed successfully!");
 
         } catch (\Throwable $e) {
-            Console::error("Error: " . $e->getMessage());
-            Console::error("Trace: " . $e->getTraceAsString());
+            Console::error('Error: '.$e->getMessage());
+            Console::error('Trace: '.$e->getTraceAsString());
+
             return;
         }
     });
@@ -139,7 +143,7 @@
  */
 function setupTestEnvironment(Database $database, string $name, int $seed): void
 {
-    Console::info("Setting up test environment...");
+    Console::info('Setting up test environment...');
 
     // Delete database if it exists
     if ($database->exists($name)) {
@@ -147,41 +151,41 @@ function setupTestEnvironment(Database $database, string $name, int $seed): void
     }
     $database->create();
 
-    $authorization->addRole(Role::any()->toString());
+    $database->getAuthorization()->addRole(Role::any()->toString());
 
     // Create test collection
-    $database->createCollection('operators_test', permissions: [
+    $database->createCollection(new Collection(id: 'operators_test', permissions: [
         Permission::create(Role::any()),
         Permission::read(Role::any()),
         Permission::update(Role::any()),
         Permission::delete(Role::any()),
-    ]);
+    ]));
 
     // Create attributes for all operator types
     // Numeric attributes
-    $database->createAttribute('operators_test', 'counter', Database::VAR_INTEGER, 0, false, 0);
-    $database->createAttribute('operators_test', 'score', Database::VAR_FLOAT, 0, false, 0.0);
-    $database->createAttribute('operators_test', 'multiplier', Database::VAR_FLOAT, 0, false, 1.0);
-    $database->createAttribute('operators_test', 'divider', Database::VAR_FLOAT, 0, false, 100.0);
-    $database->createAttribute('operators_test', 'modulo_val', Database::VAR_INTEGER, 0, false, 100);
-    $database->createAttribute('operators_test', 'power_val', Database::VAR_FLOAT, 0, false, 2.0);
+    $database->createAttribute('operators_test', Attribute::integer(key: 'counter', size: 0, required: false, default: 0));
+    $database->createAttribute('operators_test', Attribute::float(key: 'score', size: 0, required: false, default: 0.0));
+    $database->createAttribute('operators_test', Attribute::float(key: 'multiplier', size: 0, required: false, default: 1.0));
+    $database->createAttribute('operators_test', Attribute::float(key: 'divider', size: 0, required: false, default: 100.0));
+    $database->createAttribute('operators_test', Attribute::integer(key: 'modulo_val', size: 0, required: false, default: 100));
+    $database->createAttribute('operators_test', Attribute::float(key: 'power_val', size: 0, required: false, default: 2.0));
 
     // String attributes
-    $database->createAttribute('operators_test', 'name', Database::VAR_STRING, 200, false, 'test');
-    $database->createAttribute('operators_test', 'text', Database::VAR_STRING, 500, false, 'initial');
-    $database->createAttribute('operators_test', 'description', Database::VAR_STRING, 500, false, 'foo bar baz');
+    $database->createAttribute('operators_test', Attribute::string(key: 'name', size: 200, required: false, default: 'test'));
+    $database->createAttribute('operators_test', Attribute::string(key: 'text', size: 500, required: false, default: 'initial'));
+    $database->createAttribute('operators_test', Attribute::string(key: 'description', size: 500, required: false, default: 'foo bar baz'));
 
     // Boolean attributes
-    $database->createAttribute('operators_test', 'active', Database::VAR_BOOLEAN, 0, false, true);
+    $database->createAttribute('operators_test', Attribute::boolean(key: 'active', size: 0, required: false, default: true));
 
     // Array attributes
-    $database->createAttribute('operators_test', 'tags', Database::VAR_STRING, 50, false, null, true, true);
-    $database->createAttribute('operators_test', 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-    $database->createAttribute('operators_test', 'items', Database::VAR_STRING, 50, false, null, true, true);
+    $database->createAttribute('operators_test', Attribute::string(key: 'tags', size: 50, required: false, default: null, signed: true, array: true));
+    $database->createAttribute('operators_test', Attribute::integer(key: 'numbers', size: 0, required: false, default: null, signed: true, array: true));
+    $database->createAttribute('operators_test', Attribute::string(key: 'items', size: 50, required: false, default: null, signed: true, array: true));
 
     // Date attributes
-    $database->createAttribute('operators_test', 'created_at', Database::VAR_DATETIME, 0, false, null, false, false, null, [], ['datetime']);
-    $database->createAttribute('operators_test', 'updated_at', Database::VAR_DATETIME, 0, false, null, false, false, null, [], ['datetime']);
+    $database->createAttribute('operators_test', Attribute::datetime(key: 'created_at', size: 0, required: false, default: null, signed: false, array: false, format: null, formatOptions: [], filters: ['datetime']));
+    $database->createAttribute('operators_test', Attribute::datetime(key: 'updated_at', size: 0, required: false, default: null, signed: false, array: false, format: null, formatOptions: [], filters: ['datetime']));
 
     // Seed documents if requested
     if ($seed > 0) {
@@ -210,7 +214,7 @@ function seedDocuments(Database $database, int $count): void
         for ($i = 0; $i < $remaining; $i++) {
             $docNum = ($batch * $batchSize) + $i;
             $docs[] = new Document([
-                '$id' => 'seed_' . $docNum,
+                '$id' => 'seed_'.$docNum,
                 '$permissions' => [
                     Permission::read(Role::any()),
                     Permission::update(Role::any()),
@@ -221,13 +225,13 @@ function seedDocuments(Database $database, int $count): void
                 'divider' => round(rand(5000, 15000) / 100, 2),
                 'modulo_val' => rand(50, 200),
                 'power_val' => round(rand(100, 300) / 100, 2),
-                'name' => 'seed_doc_' . $docNum,
-                'text' => 'Seed text for document ' . $docNum,
-                'description' => 'This is seed document ' . $docNum . ' with some foo bar baz content',
+                'name' => 'seed_doc_'.$docNum,
+                'text' => 'Seed text for document '.$docNum,
+                'description' => 'This is seed document '.$docNum.' with some foo bar baz content',
                 'active' => (bool) rand(0, 1),
-                'tags' => ['seed', 'tag' . ($docNum % 10), 'category' . ($docNum % 5)],
+                'tags' => ['seed', 'tag'.($docNum % 10), 'category'.($docNum % 5)],
                 'numbers' => [rand(1, 10), rand(11, 20), rand(21, 30)],
-                'items' => ['item' . ($docNum % 3), 'item' . ($docNum % 7)],
+                'items' => ['item'.($docNum % 3), 'item'.($docNum % 7)],
                 'created_at' => DateTime::now(),
                 'updated_at' => DateTime::now(),
             ]);
@@ -243,7 +247,7 @@ function seedDocuments(Database $database, int $count): void
     }
 
     $seedTime = microtime(true) - $seedStart;
-    Console::success("Seeding completed in " . number_format($seedTime, 2) . "s\n");
+    Console::success('Seeding completed in '.number_format($seedTime, 2)."s\n");
 }
 
 /**
@@ -262,7 +266,7 @@ function runAllBenchmarks(Database $database, int $iterations): array
             $results[$name] = $benchmark();
         } catch (\Throwable $e) {
             $failed[$name] = $e->getMessage();
-            Console::warning("  ⚠️  {$name} failed: " . $e->getMessage());
+            Console::warning("  ⚠️  {$name} failed: ".$e->getMessage());
         }
     };
 
@@ -343,6 +347,7 @@ function runAllBenchmarks(Database $database, int $iterations): array
         Operator::increment(1),
         function ($doc) {
             $doc->setAttribute('counter', $doc->getAttribute('counter', 0) + 1);
+
             return $doc;
         },
         ['counter' => 0]
@@ -356,6 +361,7 @@ function ($doc) {
         Operator::decrement(1),
         function ($doc) {
             $doc->setAttribute('counter', $doc->getAttribute('counter', 100) - 1);
+
             return $doc;
         },
         ['counter' => 100]
@@ -369,6 +375,7 @@ function ($doc) {
         Operator::multiply(1.1),
         function ($doc) {
             $doc->setAttribute('multiplier', $doc->getAttribute('multiplier', 1.0) * 1.1);
+
             return $doc;
         },
         ['multiplier' => 1.0]
@@ -382,6 +389,7 @@ function ($doc) {
         Operator::divide(1.1),
         function ($doc) {
             $doc->setAttribute('divider', $doc->getAttribute('divider', 100.0) / 1.1);
+
             return $doc;
         },
         ['divider' => 100.0]
@@ -396,6 +404,7 @@ function ($doc) {
         function ($doc) {
             $val = $doc->getAttribute('modulo_val', 100);
             $doc->setAttribute('modulo_val', $val % 7);
+
             return $doc;
         },
         ['modulo_val' => 100]
@@ -409,6 +418,7 @@ function ($doc) {
         Operator::power(1.001),
         function ($doc) {
             $doc->setAttribute('power_val', pow($doc->getAttribute('power_val', 2.0), 1.001));
+
             return $doc;
         },
         ['power_val' => 2.0]
@@ -422,7 +432,8 @@ function ($doc) {
         'text',
         Operator::stringConcat('x'),
         function ($doc) {
-            $doc->setAttribute('text', $doc->getAttribute('text', 'initial') . 'x');
+            $doc->setAttribute('text', $doc->getAttribute('text', 'initial').'x');
+
             return $doc;
         },
         ['text' => 'initial']
@@ -436,6 +447,7 @@ function ($doc) {
         Operator::stringReplace('foo', 'bar'),
         function ($doc) {
             $doc->setAttribute('description', str_replace('foo', 'bar', $doc->getAttribute('description', 'foo bar baz')));
+
             return $doc;
         },
         ['description' => 'foo bar baz']
@@ -449,7 +461,8 @@ function ($doc) {
         'active',
         Operator::toggle(),
         function ($doc) {
-            $doc->setAttribute('active', !$doc->getAttribute('active', true));
+            $doc->setAttribute('active', ! $doc->getAttribute('active', true));
+
             return $doc;
         },
         ['active' => true]
@@ -466,6 +479,7 @@ function ($doc) {
             $tags = $doc->getAttribute('tags', ['initial']);
             $tags[] = 'new';
             $doc->setAttribute('tags', $tags);
+
             return $doc;
         },
         ['tags' => ['initial']]
@@ -481,6 +495,7 @@ function ($doc) {
             $tags = $doc->getAttribute('tags', ['initial']);
             array_unshift($tags, 'first');
             $doc->setAttribute('tags', $tags);
+
             return $doc;
         },
         ['tags' => ['initial']]
@@ -496,6 +511,7 @@ function ($doc) {
             $numbers = $doc->getAttribute('numbers', [1, 2, 3]);
             array_splice($numbers, 1, 0, [99]);
             $doc->setAttribute('numbers', $numbers);
+
             return $doc;
         },
         ['numbers' => [1, 2, 3]]
@@ -511,6 +527,7 @@ function ($doc) {
             $tags = $doc->getAttribute('tags', ['keep', 'unwanted', 'also']);
             $tags = array_values(array_filter($tags, fn ($t) => $t !== 'unwanted'));
             $doc->setAttribute('tags', $tags);
+
             return $doc;
         },
         ['tags' => ['keep', 'unwanted', 'also']]
@@ -525,6 +542,7 @@ function ($doc) {
         function ($doc) {
             $tags = $doc->getAttribute('tags', ['a', 'b', 'a', 'c', 'b']);
             $doc->setAttribute('tags', array_values(array_unique($tags)));
+
             return $doc;
         },
         ['tags' => ['a', 'b', 'a', 'c', 'b']]
@@ -539,6 +557,7 @@ function ($doc) {
         function ($doc) {
             $tags = $doc->getAttribute('tags', ['keep', 'remove', 'this']);
             $doc->setAttribute('tags', array_values(array_intersect($tags, ['keep', 'this'])));
+
             return $doc;
         },
         ['tags' => ['keep', 'remove', 'this']]
@@ -553,6 +572,7 @@ function ($doc) {
         function ($doc) {
             $tags = $doc->getAttribute('tags', ['keep', 'remove', 'this']);
             $doc->setAttribute('tags', array_values(array_diff($tags, ['remove'])));
+
             return $doc;
         },
         ['tags' => ['keep', 'remove', 'this']]
@@ -567,6 +587,7 @@ function ($doc) {
         function ($doc) {
             $numbers = $doc->getAttribute('numbers', [1, 3, 5, 7, 9]);
             $doc->setAttribute('numbers', array_values(array_filter($numbers, fn ($n) => $n > 5)));
+
             return $doc;
         },
         ['numbers' => [1, 3, 5, 7, 9]]
@@ -583,6 +604,7 @@ function ($doc) {
             $date = new \DateTime($doc->getAttribute('created_at', DateTime::now()));
             $date->modify('+1 day');
             $doc->setAttribute('created_at', DateTime::format($date));
+
             return $doc;
         },
         ['created_at' => DateTime::now()]
@@ -598,6 +620,7 @@ function ($doc) {
             $date = new \DateTime($doc->getAttribute('updated_at', DateTime::now()));
             $date->modify('-1 day');
             $doc->setAttribute('updated_at', DateTime::format($date));
+
             return $doc;
         },
         ['updated_at' => DateTime::now()]
@@ -611,16 +634,17 @@ function ($doc) {
         Operator::dateSetNow(),
         function ($doc) {
             $doc->setAttribute('updated_at', DateTime::now());
+
             return $doc;
         },
         ['updated_at' => DateTime::now()]
     ));
 
     // Report any failures
-    if (!empty($failed)) {
+    if (! empty($failed)) {
         Console::warning("\n⚠️  Some benchmarks failed:");
         foreach ($failed as $name => $error) {
-            Console::warning("  - {$name}: " . substr($error, 0, 100));
+            Console::warning("  - {$name}: ".substr($error, 0, 100));
         }
     }
 
@@ -637,10 +661,10 @@ function benchmarkOperation(
     bool $isBulk,
     bool $useOperators
 ): array {
-    $displayName = strtoupper($operation) . ($useOperators ? ' (with ops)' : ' (no ops)');
+    $displayName = strtoupper($operation).($useOperators ? ' (with ops)' : ' (no ops)');
     Console::info("Benchmarking {$displayName}...");
 
-    $docId = 'bench_op_' . strtolower($operation) . '_' . ($useOperators ? 'ops' : 'noops');
+    $docId = 'bench_op_'.strtolower($operation).'_'.($useOperators ? 'ops' : 'noops');
 
     // Create initial document
     $baseData = [
@@ -650,7 +674,7 @@ function benchmarkOperation(
         ],
         'counter' => 0,
         'name' => 'test',
-        'score' => 100.0
+        'score' => 100.0,
     ];
 
     $database->createDocument('operators_test', new Document(array_merge(['$id' => $docId], $baseData)));
@@ -662,11 +686,11 @@ function benchmarkOperation(
         if ($operation === 'updateDocument') {
             if ($useOperators) {
                 $database->updateDocument('operators_test', $docId, new Document([
-                    'counter' => Operator::increment(1)
+                    'counter' => Operator::increment(1),
                 ]));
             } else {
                 $database->updateDocument('operators_test', $docId, new Document([
-                    'counter' => $i + 1
+                    'counter' => $i + 1,
                 ]));
             }
         } elseif ($operation === 'updateDocuments') {
@@ -680,7 +704,7 @@ function benchmarkOperation(
                 // because updateDocuments with queries would apply the same value to all matching docs
                 $doc = $database->getDocument('operators_test', $docId);
                 $database->updateDocument('operators_test', $docId, new Document([
-                    'counter' => $i + 1
+                    'counter' => $i + 1,
                 ]));
             }
         } elseif ($operation === 'upsertDocument') {
@@ -689,24 +713,24 @@ function benchmarkOperation(
                     '$id' => $docId,
                     'counter' => Operator::increment(1),
                     'name' => 'test',
-                    'score' => 100.0
+                    'score' => 100.0,
                 ]));
             } else {
                 $database->upsertDocument('operators_test', new Document([
                     '$id' => $docId,
                     'counter' => $i + 1,
                     'name' => 'test',
-                    'score' => 100.0
+                    'score' => 100.0,
                 ]));
             }
         } elseif ($operation === 'upsertDocuments') {
             if ($useOperators) {
                 $database->upsertDocuments('operators_test', [
-                    new Document(['$id' => $docId, 'counter' => Operator::increment(1), 'name' => 'test', 'score' => 100.0])
+                    new Document(['$id' => $docId, 'counter' => Operator::increment(1), 'name' => 'test', 'score' => 100.0]),
                 ]);
             } else {
                 $database->upsertDocuments('operators_test', [
-                    new Document(['$id' => $docId, 'counter' => $i + 1, 'name' => 'test', 'score' => 100.0])
+                    new Document(['$id' => $docId, 'counter' => $i + 1, 'name' => 'test', 'score' => 100.0]),
                 ]);
             }
         }
@@ -718,7 +742,7 @@ function benchmarkOperation(
     // Cleanup
     $database->deleteDocument('operators_test', $docId);
 
-    Console::success("  Time: {$timeOp}s | Memory: " . formatBytes($memOp));
+    Console::success("  Time: {$timeOp}s | Memory: ".formatBytes($memOp));
 
     return [
         'operation' => $operation,
@@ -753,8 +777,9 @@ function benchmarkOperatorAcrossOperations(
 
     foreach ($operationTypes as $opType => $method) {
         // Skip upsert operations if not supported
-        if (str_contains($method, 'upsert') && !$database->getAdapter()->getSupportForUpserts()) {
+        if (str_contains($method, 'upsert') && ! ($database->getAdapter() instanceof Feature\Upserts)) {
             Console::warning("  Skipping {$opType} (not supported by adapter)");
+
             continue;
         }
 
@@ -772,7 +797,7 @@ function benchmarkOperatorAcrossOperations(
         // Create documents for with-operator test
         $docIdsWith = [];
         for ($i = 0; $i < $docCount; $i++) {
-            $docId = 'bench_with_' . strtolower($operatorName) . '_' . strtolower($opType) . '_' . $i;
+            $docId = 'bench_with_'.strtolower($operatorName).'_'.strtolower($opType).'_'.$i;
             $docIdsWith[] = $docId;
             $database->createDocument('operators_test', new Document(array_merge(['$id' => $docId], $baseData)));
         }
@@ -780,7 +805,7 @@ function benchmarkOperatorAcrossOperations(
         // Create documents for without-operator test
         $docIdsWithout = [];
         for ($i = 0; $i < $docCount; $i++) {
-            $docId = 'bench_without_' . strtolower($operatorName) . '_' . strtolower($opType) . '_' . $i;
+            $docId = 'bench_without_'.strtolower($operatorName).'_'.strtolower($opType).'_'.$i;
             $docIdsWithout[] = $docId;
             $database->createDocument('operators_test', new Document(array_merge(['$id' => $docId], $baseData)));
         }
@@ -792,7 +817,7 @@ function benchmarkOperatorAcrossOperations(
         for ($i = 0; $i < $iterations; $i++) {
             if ($method === 'updateDocument') {
                 $database->updateDocument('operators_test', $docIdsWith[0], new Document([
-                    $attribute => $operator
+                    $attribute => $operator,
                 ]));
             } elseif ($method === 'updateDocuments') {
                 $updates = new Document([$attribute => $operator]);
@@ -915,8 +940,8 @@ function benchmarkOperatorAcrossOperations(
 function displayResults(array $results, string $adapter, int $iterations, int $seed): void
 {
     Console::info("\n=============================================================");
-    Console::info("  BENCHMARK RESULTS");
-    Console::info("=============================================================");
+    Console::info('  BENCHMARK RESULTS');
+    Console::info('=============================================================');
     Console::info("Adapter: {$adapter}");
     Console::info("Iterations per test: {$iterations}");
     Console::info("Seeded documents: {$seed}");
@@ -931,8 +956,8 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
     $opTypes = ['UPDATE_SINGLE', 'UPDATE_BULK', 'UPSERT_SINGLE', 'UPSERT_BULK'];
 
     foreach ($opTypes as $opType) {
-        $noOpsKey = $opType . '_NO_OPS';
-        $withOpsKey = $opType . '_WITH_OPS';
+        $noOpsKey = $opType.'_NO_OPS';
+        $withOpsKey = $opType.'_WITH_OPS';
 
         if (isset($results[$noOpsKey]) && isset($results[$withOpsKey])) {
             $noOps = $results[$noOpsKey];
@@ -941,10 +966,10 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
             $timeNoOps = number_format($noOps['time'], 4);
             $timeWithOps = number_format($withOps['time'], 4);
 
-            Console::info(str_pad($opType, 20) . ":");
+            Console::info(str_pad($opType, 20).':');
             Console::info("  NO operators:   {$timeNoOps}s");
             Console::info("  WITH operators: {$timeWithOps}s");
-            Console::info("");
+            Console::info('');
         }
     }
 
@@ -990,7 +1015,7 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
         Console::info("\n{$categoryName} Operators:");
 
         foreach ($operators as $operatorName) {
-            if (!isset($results[$operatorName])) {
+            if (! isset($results[$operatorName])) {
                 continue;
             }
 
@@ -998,8 +1023,9 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
 
             Console::info("\n  {$operatorName}:");
 
-            if (!isset($result['operations'])) {
-                Console::warning("    No results (benchmark failed)");
+            if (! isset($result['operations'])) {
+                Console::warning('    No results (benchmark failed)');
+
                 continue;
             }
 
@@ -1040,14 +1066,14 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
     // Summary statistics
     $avgSpeedup = $totalCount > 0 ? $totalSpeedup / $totalCount : 0;
 
-    Console::info("\n" . str_repeat('=', array_sum($colWidths) + 5));
-    Console::info("SUMMARY:");
+    Console::info("\n".str_repeat('=', array_sum($colWidths) + 5));
+    Console::info('SUMMARY:');
     Console::info("  Total operators tested: {$totalCount}");
-    Console::info("  Average speedup: " . number_format($avgSpeedup, 2) . "x");
+    Console::info('  Average speedup: '.number_format($avgSpeedup, 2).'x');
 
     // Performance insights
-    Console::info("\n" . str_repeat('=', array_sum($colWidths) + 5));
-    Console::info("PERFORMANCE INSIGHTS:");
+    Console::info("\n".str_repeat('=', array_sum($colWidths) + 5));
+    Console::info('PERFORMANCE INSIGHTS:');
 
     // Flatten results for fastest/slowest calculation
     $flattenedResults = [];
@@ -1063,25 +1089,23 @@ function displayResults(array $results, string $adapter, int $iterations, int $s
         }
     }
 
-    if (!empty($flattenedResults)) {
+    if (! empty($flattenedResults)) {
         $fastest = array_reduce(
             $flattenedResults,
-            fn ($carry, $item) =>
-            $carry === null || $item['speedup'] > $carry['speedup'] ? $item : $carry
+            fn ($carry, $item) => $carry === null || $item['speedup'] > $carry['speedup'] ? $item : $carry
         );
 
         $slowest = array_reduce(
             $flattenedResults,
-            fn ($carry, $item) =>
-            $carry === null || $item['speedup'] < $carry['speedup'] ? $item : $carry
+            fn ($carry, $item) => $carry === null || $item['speedup'] < $carry['speedup'] ? $item : $carry
         );
 
         if ($fastest) {
-            Console::success("  Fastest: {$fastest['operator']} ({$fastest['operation']}) - " . number_format($fastest['speedup'], 2) . "x speedup");
+            Console::success("  Fastest: {$fastest['operator']} ({$fastest['operation']}) - ".number_format($fastest['speedup'], 2).'x speedup');
         }
 
         if ($slowest) {
-            Console::warning("  Slowest: {$slowest['operator']} ({$slowest['operation']}) - " . number_format($slowest['speedup'], 2) . "x speedup");
+            Console::warning("  Slowest: {$slowest['operator']} ({$slowest['operation']}) - ".number_format($slowest['speedup'], 2).'x speedup');
         }
     }
 
@@ -1104,7 +1128,7 @@ function formatBytes(int $bytes): string
     $power = floor(log($bytes, 1024));
     $power = min($power, count($units) - 1);
 
-    return $sign . round($bytes / pow(1024, $power), 2) . ' ' . $units[$power];
+    return $sign.round($bytes / pow(1024, $power), 2).' '.$units[$power];
 }
 
 /**
@@ -1112,14 +1136,14 @@ function formatBytes(int $bytes): string
  */
 function cleanup(Database $database, string $name): void
 {
-    Console::info("Cleaning up test environment...");
+    Console::info('Cleaning up test environment...');
 
     try {
         if ($database->exists($name)) {
             $database->delete($name);
         }
-        Console::success("Cleanup complete.");
+        Console::success('Cleanup complete.');
     } catch (\Throwable $e) {
-        Console::warning("Cleanup failed: " . $e->getMessage());
+        Console::warning('Cleanup failed: '.$e->getMessage());
     }
 }
diff --git a/bin/tasks/query.php b/bin/tasks/query.php
index d6c9987142..c825bd2b27 100644
--- a/bin/tasks/query.php
+++ b/bin/tasks/query.php
@@ -24,7 +24,6 @@
  * @Example
  * docker compose exec tests bin/query --adapter=mariadb --limit=1000 --name=testing
  */
-
 $cli
     ->task('query')
     ->desc('Query mock data')
@@ -38,6 +37,7 @@
             for ($i = 0; $i < $count; $i++) {
                 $authorization->addRole($faker->numerify('user####'));
             }
+
             return \count($authorization->getRoles());
         };
 
@@ -77,8 +77,9 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
@@ -104,38 +105,38 @@
         Console::info("\nRunning queries with {$count} authorization roles:");
         $report[] = [
             'roles' => $count,
-            'results' => runQueries($database, $limit)
+            'results' => runQueries($database, $limit),
         ];
 
         $count = $setRoles($database->getAuthorization(), $faker, 100);
         Console::info("\nRunning queries with {$count} authorization roles:");
         $report[] = [
             'roles' => $count,
-            'results' => runQueries($database, $limit)
+            'results' => runQueries($database, $limit),
         ];
 
         $count = $setRoles($database->getAuthorization(), $faker, 400);
         Console::info("\nRunning queries with {$count} authorization roles:");
         $report[] = [
             'roles' => $count,
-            'results' => runQueries($database, $limit)
+            'results' => runQueries($database, $limit),
         ];
 
         $count = $setRoles($database->getAuthorization(), $faker, 500);
         Console::info("\nRunning queries with {$count} authorization roles:");
         $report[] = [
             'roles' => $count,
-            'results' => runQueries($database, $limit)
+            'results' => runQueries($database, $limit),
         ];
 
         $count = $setRoles($database->getAuthorization(), $faker, 1000);
         Console::info("\nRunning queries with {$count} authorization roles:");
         $report[] = [
             'roles' => $count,
-            'results' => runQueries($database, $limit)
+            'results' => runQueries($database, $limit),
         ];
 
-        if (!file_exists('bin/view/results')) {
+        if (! file_exists('bin/view/results')) {
             \mkdir('bin/view/results', 0777, true);
         }
 
@@ -145,40 +146,39 @@
         \fclose($results);
     });
 
-
 function runQueries(Database $database, int $limit): array
 {
     $results = [];
 
     // Recent travel blogs
-    $results["Querying greater than, equal[1] and limit"] = runQuery([
+    $results['Querying greater than, equal[1] and limit'] = runQuery([
         Query::greaterThan('created', '2010-01-01 05:00:00'),
         Query::equal('genre', ['travel']),
-        Query::limit($limit)
+        Query::limit($limit),
     ], $database);
 
     // Favorite genres
-    $results["Querying equal[3] and limit"] = runQuery([
+    $results['Querying equal[3] and limit'] = runQuery([
         Query::equal('genre', ['fashion', 'finance', 'sports']),
-        Query::limit($limit)
+        Query::limit($limit),
     ], $database);
 
     // Popular posts
     $results["Querying greaterThan, limit({$limit})"] = runQuery([
         Query::greaterThan('views', 100000),
-        Query::limit($limit)
+        Query::limit($limit),
     ], $database);
 
     // Fulltext search
     $results["Query search, limit({$limit})"] = runQuery([
         Query::search('text', 'Alice'),
-        Query::limit($limit)
+        Query::limit($limit),
     ], $database);
 
     // Tags contain query
     $results["Querying contains[1], limit({$limit})"] = runQuery([
         Query::contains('tags', ['tag1']),
-        Query::limit($limit)
+        Query::limit($limit),
     ], $database);
 
     return $results;
@@ -187,13 +187,14 @@ function runQueries(Database $database, int $limit): array
 function runQuery(array $query, Database $database)
 {
     $info = array_map(function (Query $q) {
-        return $q->getAttribute() . ': ' . $q->getMethod() . ' = ' . implode(',', $q->getValues());
+        return $q->getAttribute().': '.$q->getMethod()->value.' = '.implode(',', $q->getValues());
     }, $query);
 
-    Console::info("Running query: [" . implode(', ', $info) . "]");
+    Console::info('Running query: ['.implode(', ', $info).']');
     $start = microtime(true);
     $database->find('articles', $query);
     $time = microtime(true) - $start;
     Console::success("Query executed in {$time} seconds");
+
     return $time;
 }
diff --git a/bin/tasks/relationships.php b/bin/tasks/relationships.php
index 790845b9cd..3bbf39c8f8 100644
--- a/bin/tasks/relationships.php
+++ b/bin/tasks/relationships.php
@@ -13,6 +13,8 @@
 use Utopia\Database\Adapter\MariaDB;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -20,6 +22,9 @@
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\PDO;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ForeignKeyAction;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Integer;
 use Utopia\Validator\Text;
@@ -33,13 +38,12 @@
  * @Example
  * docker compose exec tests bin/relationships --adapter=mariadb --limit=1000
  */
-
 $cli
     ->task('relationships')
     ->desc('Load database with mock relationships for testing')
     ->param('adapter', '', new Text(0), 'Database adapter')
     ->param('limit', 0, new Integer(true), 'Total number of records to add to database')
-    ->param('name', 'myapp_' . uniqid(), new Text(0), 'Name of created database.', true)
+    ->param('name', 'myapp_'.uniqid(), new Text(0), 'Name of created database.', true)
     ->param('sharedTables', false, new Boolean(true), 'Whether to use shared tables', true)
     ->param('runs', 1, new Integer(true), 'Number of times to run benchmarks', true)
     ->action(function (string $adapter, int $limit, string $name, bool $sharedTables, int $runs) {
@@ -55,67 +59,67 @@
             }
             $database->getAuthorization()->addRole(Role::any()->toString());
             $database->create();
-            $database->createCollection('authors', permissions: [
+            $database->createCollection(new Collection(id: 'authors', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('authors', 'name', Database::VAR_STRING, 256, true);
-            $database->createAttribute('authors', 'created', Database::VAR_DATETIME, 0, true, filters: ['datetime']);
-            $database->createAttribute('authors', 'bio', Database::VAR_STRING, 5000, true);
-            $database->createAttribute('authors', 'avatar', Database::VAR_STRING, 256, true);
-            $database->createAttribute('authors', 'website', Database::VAR_STRING, 256, true);
-
-            $database->createCollection('articles', permissions: [
+            ]));
+            $database->createAttribute('authors', Attribute::string(key: 'name', size: 256, required: true));
+            $database->createAttribute('authors', Attribute::datetime(key: 'created', size: 0, required: true, filters: ['datetime']));
+            $database->createAttribute('authors', Attribute::string(key: 'bio', size: 5000, required: true));
+            $database->createAttribute('authors', Attribute::string(key: 'avatar', size: 256, required: true));
+            $database->createAttribute('authors', Attribute::string(key: 'website', size: 256, required: true));
+
+            $database->createCollection(new Collection(id: 'articles', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('articles', 'title', Database::VAR_STRING, 256, true);
-            $database->createAttribute('articles', 'text', Database::VAR_STRING, 5000, true);
-            $database->createAttribute('articles', 'genre', Database::VAR_STRING, 256, true);
-            $database->createAttribute('articles', 'views', Database::VAR_INTEGER, 0, true);
-            $database->createAttribute('articles', 'tags', Database::VAR_STRING, 0, true, array: true);
-
-            $database->createCollection('users', permissions: [
+            ]));
+            $database->createAttribute('articles', Attribute::string(key: 'title', size: 256, required: true));
+            $database->createAttribute('articles', Attribute::string(key: 'text', size: 5000, required: true));
+            $database->createAttribute('articles', Attribute::string(key: 'genre', size: 256, required: true));
+            $database->createAttribute('articles', Attribute::integer(key: 'views', size: 0, required: true));
+            $database->createAttribute('articles', Attribute::string(key: 'tags', size: 0, required: true, array: true));
+
+            $database->createCollection(new Collection(id: 'users', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('users', 'username', Database::VAR_STRING, 256, true);
-            $database->createAttribute('users', 'email', Database::VAR_STRING, 256, true);
-            $database->createAttribute('users', 'password', Database::VAR_STRING, 256, true);
+            ]));
+            $database->createAttribute('users', Attribute::string(key: 'username', size: 256, required: true));
+            $database->createAttribute('users', Attribute::string(key: 'email', size: 256, required: true));
+            $database->createAttribute('users', Attribute::string(key: 'password', size: 256, required: true));
 
-            $database->createCollection('comments', permissions: [
+            $database->createCollection(new Collection(id: 'comments', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('comments', 'content', Database::VAR_STRING, 256, true);
-            $database->createAttribute('comments', 'likes', Database::VAR_INTEGER, 8, true, signed: false);
+            ]));
+            $database->createAttribute('comments', Attribute::string(key: 'content', size: 256, required: true));
+            $database->createAttribute('comments', Attribute::integer(key: 'likes', size: 8, required: true, signed: false));
 
-            $database->createCollection('profiles', permissions: [
+            $database->createCollection(new Collection(id: 'profiles', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('profiles', 'bio_extended', Database::VAR_STRING, 10000, true);
-            $database->createAttribute('profiles', 'social_links', Database::VAR_STRING, 256, true, array: true);
-            $database->createAttribute('profiles', 'verified', Database::VAR_BOOLEAN, 0, true);
+            ]));
+            $database->createAttribute('profiles', Attribute::string(key: 'bio_extended', size: 10000, required: true));
+            $database->createAttribute('profiles', Attribute::string(key: 'social_links', size: 256, required: true, array: true));
+            $database->createAttribute('profiles', Attribute::boolean(key: 'verified', size: 0, required: true));
 
-            $database->createCollection('categories', permissions: [
+            $database->createCollection(new Collection(id: 'categories', permissions: [
                 Permission::create(Role::any()),
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
-            ]);
-            $database->createAttribute('categories', 'name', Database::VAR_STRING, 256, true);
-            $database->createAttribute('categories', 'description', Database::VAR_STRING, 1000, true);
-
-            $database->createRelationship('authors', 'articles', Database::RELATION_MANY_TO_MANY, true, onDelete: Database::RELATION_MUTATE_SET_NULL);
-            $database->createRelationship('articles', 'comments', Database::RELATION_ONE_TO_MANY, true, twoWayKey: 'article', onDelete: Database::RELATION_MUTATE_CASCADE);
-            $database->createRelationship('users', 'comments', Database::RELATION_ONE_TO_MANY, true, twoWayKey: 'user', onDelete: Database::RELATION_MUTATE_CASCADE);
-            $database->createRelationship('authors', 'profiles', Database::RELATION_ONE_TO_ONE, true, twoWayKey: 'author', onDelete: Database::RELATION_MUTATE_CASCADE);
-            $database->createRelationship('articles', 'categories', Database::RELATION_MANY_TO_ONE, true, id: 'category', twoWayKey: 'articles', onDelete: Database::RELATION_MUTATE_SET_NULL);
+            ]));
+            $database->createAttribute('categories', Attribute::string(key: 'name', size: 256, required: true));
+            $database->createAttribute('categories', Attribute::string(key: 'description', size: 1000, required: true));
+
+            $database->createRelationship(new Relationship(collection: 'authors', relatedCollection: 'articles', type: RelationType::ManyToMany, twoWay: true, onDelete: ForeignKeyAction::SetNull));
+            $database->createRelationship(new Relationship(collection: 'articles', relatedCollection: 'comments', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'article', onDelete: ForeignKeyAction::Cascade));
+            $database->createRelationship(new Relationship(collection: 'users', relatedCollection: 'comments', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'user', onDelete: ForeignKeyAction::Cascade));
+            $database->createRelationship(new Relationship(collection: 'authors', relatedCollection: 'profiles', type: RelationType::OneToOne, twoWay: true, twoWayKey: 'author', onDelete: ForeignKeyAction::Cascade));
+            $database->createRelationship(new Relationship(collection: 'articles', relatedCollection: 'categories', type: RelationType::ManyToOne, twoWay: true, key: 'category', twoWayKey: 'articles', onDelete: ForeignKeyAction::SetNull));
         };
 
         $dbAdapters = [
@@ -148,8 +152,9 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
@@ -234,20 +239,19 @@
         displayBenchmarkResults($results, $runs);
     });
 
-
 function createGlobalDocuments(Database $database, int $limit): array
 {
     global $genresPool, $namesPool;
 
     // Scale categories based on limit (minimum 9, scales up to 100 max)
-    $numCategories = min(100, max(9, (int)($limit / 10000)));
+    $numCategories = min(100, max(9, (int) ($limit / 10000)));
     $categoryDocs = [];
     for ($i = 0; $i < $numCategories; $i++) {
         $genre = $genresPool[$i % count($genresPool)];
         $categoryDocs[] = new Document([
-            '$id' => 'category_' . \uniqid(),
-            'name' => \ucfirst($genre) . ($i >= count($genresPool) ? ' ' . ($i + 1) : ''),
-            'description' => 'Articles about ' . $genre,
+            '$id' => 'category_'.\uniqid(),
+            'name' => \ucfirst($genre).($i >= count($genresPool) ? ' '.($i + 1) : ''),
+            'description' => 'Articles about '.$genre,
         ]);
     }
 
@@ -255,13 +259,13 @@ function createGlobalDocuments(Database $database, int $limit): array
     $database->createDocuments('categories', $categoryDocs);
 
     // Scale users based on limit (10% of total documents)
-    $numUsers = max(1000, (int)($limit / 10));
+    $numUsers = max(1000, (int) ($limit / 10));
     $userDocs = [];
     for ($u = 0; $u < $numUsers; $u++) {
         $userDocs[] = new Document([
-            '$id' => 'user_' . \uniqid(),
-            'username' => $namesPool[\array_rand($namesPool)] . '_' . $u,
-            'email' => 'user' . $u . '@example.com',
+            '$id' => 'user_'.\uniqid(),
+            'username' => $namesPool[\array_rand($namesPool)].'_'.$u,
+            'email' => 'user'.$u.'@example.com',
             'password' => \bin2hex(\random_bytes(8)),
         ]);
     }
@@ -291,18 +295,18 @@ function createRelationshipDocuments(Database $database, array $categories, arra
             'name' => $namesPool[array_rand($namesPool)],
             'created' => DateTime::now(),
             'bio' => \substr(\bin2hex(\random_bytes(32)), 0, 100),
-            'avatar' => 'https://example.com/avatar/' . $a,
-            'website' => 'https://example.com/user/' . $a,
+            'avatar' => 'https://example.com/avatar/'.$a,
+            'website' => 'https://example.com/user/'.$a,
         ]);
 
         // Create profile for author (one-to-one relationship)
         $profile = new Document([
             'bio_extended' => \substr(\bin2hex(\random_bytes(128)), 0, 500),
             'social_links' => [
-                'https://twitter.com/author' . $a,
-                'https://linkedin.com/in/author' . $a,
+                'https://twitter.com/author'.$a,
+                'https://linkedin.com/in/author'.$a,
             ],
-            'verified' => (bool)\mt_rand(0, 1),
+            'verified' => (bool) \mt_rand(0, 1),
         ]);
         $author->setAttribute('profiles', $profile);
 
@@ -310,7 +314,7 @@ function createRelationshipDocuments(Database $database, array $categories, arra
         $authorArticles = [];
         for ($i = 0; $i < $numArticlesPerAuthor; $i++) {
             $article = new Document([
-                'title' => 'Article ' . ($i + 1) . ' by ' . $author->getAttribute('name'),
+                'title' => 'Article '.($i + 1).' by '.$author->getAttribute('name'),
                 'text' => \substr(\bin2hex(\random_bytes(64)), 0, \mt_rand(100, 200)),
                 'genre' => $genresPool[array_rand($genresPool)],
                 'views' => \mt_rand(0, 1000),
@@ -322,7 +326,7 @@ function createRelationshipDocuments(Database $database, array $categories, arra
             $comments = [];
             for ($c = 0; $c < $numCommentsPerArticle; $c++) {
                 $comment = new Document([
-                    'content' => 'Comment ' . ($c + 1),
+                    'content' => 'Comment '.($c + 1),
                     'likes' => \mt_rand(0, 10000),
                     'user' => $users[\array_rand($users)],
                 ]);
@@ -463,36 +467,36 @@ function benchmarkPagination(Database $database): array
 function displayRelationshipStructure(): void
 {
     Console::success("\n========================================");
-    Console::success("Relationship Structure");
+    Console::success('Relationship Structure');
     Console::success("========================================\n");
 
-    Console::info("Collections:");
-    Console::log("  • authors      (name, created, bio, avatar, website)");
-    Console::log("  • articles     (title, text, genre, views, tags[])");
-    Console::log("  • comments     (content, likes)");
-    Console::log("  • users        (username, email, password)");
-    Console::log("  • profiles     (bio_extended, social_links[], verified)");
-    Console::log("  • categories   (name, description)");
-    Console::log("");
-
-    Console::info("Relationships:");
-    Console::log("  ┌─────────────────────────────────────────────────────────────┐");
-    Console::log("  │  authors ◄─────────────► articles  (Many-to-Many)          │");
-    Console::log("  │    └─► profiles (One-to-One)                                │");
-    Console::log("  │                                                              │");
-    Console::log("  │  articles ─────────────► comments  (One-to-Many)            │");
-    Console::log("  │    └─► categories (Many-to-One)                             │");
-    Console::log("  │                                                              │");
-    Console::log("  │  users ────────────────► comments  (One-to-Many)            │");
-    Console::log("  └─────────────────────────────────────────────────────────────┘");
-    Console::log("");
-
-    Console::info("Relationship Coverage:");
-    Console::log("  ✓ One-to-One:    authors ◄─► profiles");
-    Console::log("  ✓ One-to-Many:   articles ─► comments, users ─► comments");
-    Console::log("  ✓ Many-to-One:   articles ─► categories");
-    Console::log("  ✓ Many-to-Many:  authors ◄─► articles");
-    Console::log("");
+    Console::info('Collections:');
+    Console::log('  • authors      (name, created, bio, avatar, website)');
+    Console::log('  • articles     (title, text, genre, views, tags[])');
+    Console::log('  • comments     (content, likes)');
+    Console::log('  • users        (username, email, password)');
+    Console::log('  • profiles     (bio_extended, social_links[], verified)');
+    Console::log('  • categories   (name, description)');
+    Console::log('');
+
+    Console::info('Relationships:');
+    Console::log('  ┌─────────────────────────────────────────────────────────────┐');
+    Console::log('  │  authors ◄─────────────► articles  (Many-to-Many)          │');
+    Console::log('  │    └─► profiles (One-to-One)                                │');
+    Console::log('  │                                                              │');
+    Console::log('  │  articles ─────────────► comments  (One-to-Many)            │');
+    Console::log('  │    └─► categories (Many-to-One)                             │');
+    Console::log('  │                                                              │');
+    Console::log('  │  users ────────────────► comments  (One-to-Many)            │');
+    Console::log('  └─────────────────────────────────────────────────────────────┘');
+    Console::log('');
+
+    Console::info('Relationship Coverage:');
+    Console::log('  ✓ One-to-One:    authors ◄─► profiles');
+    Console::log('  ✓ One-to-Many:   articles ─► comments, users ─► comments');
+    Console::log('  ✓ Many-to-One:   articles ─► categories');
+    Console::log('  ✓ Many-to-Many:  authors ◄─► articles');
+    Console::log('');
 }
 
 /**
@@ -524,7 +528,7 @@ function displayBenchmarkResults(array $results, int $runs): void
     }
 
     Console::success("\n========================================");
-    Console::success("Benchmark Results (Average of {$runs} run" . ($runs > 1 ? 's' : '') . ")");
+    Console::success("Benchmark Results (Average of {$runs} run".($runs > 1 ? 's' : '').')');
     Console::success("========================================\n");
 
     // Calculate column widths
@@ -532,19 +536,19 @@ function displayBenchmarkResults(array $results, int $runs): void
     $timeWidth = 12;
 
     // Print header
-    $header = str_pad('Collection', $collectionWidth) . ' | ';
+    $header = str_pad('Collection', $collectionWidth).' | ';
     foreach ($benchmarkLabels as $label) {
-        $header .= str_pad($label, $timeWidth) . ' | ';
+        $header .= str_pad($label, $timeWidth).' | ';
     }
     Console::info($header);
     Console::info(str_repeat('-', strlen($header)));
 
     // Print results for each collection
     foreach ($collections as $collection) {
-        $row = str_pad(ucfirst($collection), $collectionWidth) . ' | ';
+        $row = str_pad(ucfirst($collection), $collectionWidth).' | ';
         foreach ($benchmarks as $benchmark) {
             $time = number_format($averages[$benchmark][$collection] * 1000, 2); // Convert to ms
-            $row .= str_pad($time . ' ms', $timeWidth) . ' | ';
+            $row .= str_pad($time.' ms', $timeWidth).' | ';
         }
         Console::log($row);
     }
diff --git a/bin/view/index.php b/bin/view/index.php
index 4afb1e6775..57091f586e 100644
--- a/bin/view/index.php
+++ b/bin/view/index.php
@@ -38,12 +38,12 @@
 const results = <?php
 
 $directory = './results';
-$scanned_directory = \array_diff(\scandir($directory), array('..', '.'));
+$scanned_directory = \array_diff(\scandir($directory), ['..', '.']);
 $results = [];
 foreach ($scanned_directory as $path) {
     $results[] = [
         'name' => $path,
-        'data' => \json_decode(\file_get_contents("{$directory}/{$path}"), true)
+        'data' => \json_decode(\file_get_contents("{$directory}/{$path}"), true),
     ];
 }
 
diff --git a/composer.json b/composer.json
index b50da19f3a..65bff51dec 100755
--- a/composer.json
+++ b/composer.json
@@ -4,7 +4,8 @@
     "type": "library",
     "keywords": ["php","framework", "upf", "utopia", "database"],
     "license": "MIT",
-    "minimum-stability": "stable",
+    "minimum-stability": "dev",
+    "prefer-stable": true,
     "autoload": {
         "psr-4": {"Utopia\\Database\\": "src/Database"}
     },
@@ -25,11 +26,11 @@
         ],
         "test": [
             "Composer\\Config::disableProcessTimeout",
-            "docker compose exec tests vendor/bin/phpunit --configuration phpunit.xml"
+            "docker compose exec tests vendor/bin/paratest --configuration phpunit.xml --functional --processes 4"
         ],
         "lint": "php -d memory_limit=2G ./vendor/bin/pint --test",
         "format": "php -d memory_limit=2G ./vendor/bin/pint",
-        "check": "./vendor/bin/phpstan analyse --level 7 src tests --memory-limit 2G",
+        "check": "./vendor/bin/phpstan analyse --memory-limit 2G",
         "coverage": "./vendor/bin/coverage-check ./tmp/clover.xml 90"
     },
     "require": {
@@ -42,24 +43,37 @@
         "utopia-php/console": "0.1.*",
         "utopia-php/cache": "^4.0 || ^5.0",
         "utopia-php/pools": "2.*",
-        "utopia-php/mongo": "1.*"
+        "utopia-php/mongo": "1.*",
+        "utopia-php/query": "0.6.*",
+        "utopia-php/async": "^0.1"
     },
     "require-dev": {
         "fakerphp/faker": "1.23.*",
-        "phpunit/phpunit": "9.*",
-        "pcov/clobber": "2.*",
+        "phpunit/phpunit": "12.5.*",
+        "brianium/paratest": "7.20.*",
         "swoole/ide-helper": "5.1.3",
-        "utopia-php/cli": "0.22.*",
+        "utopia-php/cli": "^0.22",
         "laravel/pint": "*",
-        "phpstan/phpstan": "1.*",
-        "rregeer/phpunit-coverage-check": "0.3.*"
+        "phpstan/phpstan": "2.1.*",
+        "rregeer/phpunit-coverage-check": "0.3.*",
+        "phpstan/phpstan-phpunit": "2.0.*"
     },
-    "suggests": {
+    "suggest": {
         "ext-redis": "Needed to support Redis Cache Adapter",
         "ext-pdo": "Needed to support MariaDB, MySQL or SQLite Database Adapter",
         "mongodb/mongodb": "Needed to support MongoDB Database Adapter"
 
     },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/utopia-php/async.git"
+        },
+        {
+            "type": "vcs",
+            "url": "https://github.com/utopia-php/query.git"
+        }
+    ],
     "config": {
         "allow-plugins": {
             "php-http/discovery": false,
diff --git a/composer.lock b/composer.lock
index d299d53e0c..9bfcd201d8 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,26 +4,27 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "de1a56a5d39a51711c1f26fcbcf47bdc",
+    "content-hash": "58350c12e750e8d51dc3a5660ab81c60",
     "packages": [
         {
             "name": "brick/math",
-            "version": "0.18.0",
+            "version": "0.14.8",
             "source": {
                 "type": "git",
                 "url": "https://github.com/brick/math.git",
-                "reference": "82944324d1c1bdb2c2618e89978d4e2ad78d69ad"
+                "reference": "63422359a44b7f06cae63c3b429b59e8efcc0629"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/brick/math/zipball/82944324d1c1bdb2c2618e89978d4e2ad78d69ad",
-                "reference": "82944324d1c1bdb2c2618e89978d4e2ad78d69ad",
+                "url": "https://api.github.com/repos/brick/math/zipball/63422359a44b7f06cae63c3b429b59e8efcc0629",
+                "reference": "63422359a44b7f06cae63c3b429b59e8efcc0629",
                 "shasum": ""
             },
             "require": {
                 "php": "^8.2"
             },
             "require-dev": {
+                "php-coveralls/php-coveralls": "^2.2",
                 "phpstan/phpstan": "2.1.22",
                 "phpunit/phpunit": "^11.5"
             },
@@ -55,7 +56,7 @@
             ],
             "support": {
                 "issues": "https://github.com/brick/math/issues",
-                "source": "https://github.com/brick/math/tree/0.18.0"
+                "source": "https://github.com/brick/math/tree/0.14.8"
             },
             "funding": [
                 {
@@ -63,7 +64,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2026-06-14T18:21:03+00:00"
+            "time": "2026-02-10T14:33:43+00:00"
         },
         {
             "name": "composer/semver",
@@ -144,23 +145,23 @@
         },
         {
             "name": "google/protobuf",
-            "version": "v5.35.1",
+            "version": "v4.33.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/protocolbuffers/protobuf-php.git",
-                "reference": "55bb4a7d6739b5af0927b96213c1371a3afb7cfb"
+                "reference": "84b008c23915ed94536737eae46f41ba3bccfe67"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/55bb4a7d6739b5af0927b96213c1371a3afb7cfb",
-                "reference": "55bb4a7d6739b5af0927b96213c1371a3afb7cfb",
+                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/84b008c23915ed94536737eae46f41ba3bccfe67",
+                "reference": "84b008c23915ed94536737eae46f41ba3bccfe67",
                 "shasum": ""
             },
             "require": {
-                "php": ">=8.2.0"
+                "php": ">=8.1.0"
             },
             "require-dev": {
-                "phpunit/phpunit": ">=11.5.0 <12.0.0"
+                "phpunit/phpunit": ">=10.5.62 <11.0.0"
             },
             "suggest": {
                 "ext-bcmath": "Need to support JSON deserialization"
@@ -182,9 +183,9 @@
                 "proto"
             ],
             "support": {
-                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v5.35.1"
+                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v4.33.6"
             },
-            "time": "2026-06-11T21:19:23+00:00"
+            "time": "2026-03-18T17:32:05+00:00"
         },
         {
             "name": "mongodb/mongodb",
@@ -409,16 +410,16 @@
         },
         {
             "name": "open-telemetry/api",
-            "version": "1.10.0",
+            "version": "1.9.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/api.git",
-                "reference": "7c029c4a6fd457094a20569bf98f93d95e9a7559"
+                "reference": "6f8d237ce2c304ca85f31970f788e7f074d147be"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/api/zipball/7c029c4a6fd457094a20569bf98f93d95e9a7559",
-                "reference": "7c029c4a6fd457094a20569bf98f93d95e9a7559",
+                "url": "https://api.github.com/repos/opentelemetry-php/api/zipball/6f8d237ce2c304ca85f31970f788e7f074d147be",
+                "reference": "6f8d237ce2c304ca85f31970f788e7f074d147be",
                 "shasum": ""
             },
             "require": {
@@ -475,7 +476,7 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2026-07-06T12:28:04+00:00"
+            "time": "2026-02-25T13:24:05+00:00"
         },
         {
             "name": "open-telemetry/context",
@@ -602,20 +603,20 @@
         },
         {
             "name": "open-telemetry/gen-otlp-protobuf",
-            "version": "1.10.0",
+            "version": "1.9.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/gen-otlp-protobuf.git",
-                "reference": "66f04d0e448ad333033bfc7baae1aa56330be088"
+                "reference": "a229cf161d42001d64c8f21e8f678581fe1c66b9"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/gen-otlp-protobuf/zipball/66f04d0e448ad333033bfc7baae1aa56330be088",
-                "reference": "66f04d0e448ad333033bfc7baae1aa56330be088",
+                "url": "https://api.github.com/repos/opentelemetry-php/gen-otlp-protobuf/zipball/a229cf161d42001d64c8f21e8f678581fe1c66b9",
+                "reference": "a229cf161d42001d64c8f21e8f678581fe1c66b9",
                 "shasum": ""
             },
             "require": {
-                "google/protobuf": "^3.22 || ^4.0 || ^5.0",
+                "google/protobuf": "^3.22 || ^4.0",
                 "php": "^8.0"
             },
             "suggest": {
@@ -661,20 +662,20 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2026-06-17T12:06:32+00:00"
+            "time": "2025-10-19T06:44:33+00:00"
         },
         {
             "name": "open-telemetry/sdk",
-            "version": "1.15.0",
+            "version": "1.14.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/sdk.git",
-                "reference": "77e1aa73850154abb86937d52a70883edc3b4547"
+                "reference": "6e3d0ce93e76555dd5e2f1d19443ff45b990e410"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/77e1aa73850154abb86937d52a70883edc3b4547",
-                "reference": "77e1aa73850154abb86937d52a70883edc3b4547",
+                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/6e3d0ce93e76555dd5e2f1d19443ff45b990e410",
+                "reference": "6e3d0ce93e76555dd5e2f1d19443ff45b990e410",
                 "shasum": ""
             },
             "require": {
@@ -682,7 +683,7 @@
                 "nyholm/psr7-server": "^1.1",
                 "open-telemetry/api": "^1.8",
                 "open-telemetry/context": "^1.4",
-                "open-telemetry/sem-conv": "^1.38.0",
+                "open-telemetry/sem-conv": "^1.0",
                 "php": "^8.1",
                 "php-http/discovery": "^1.14",
                 "psr/http-client": "^1.0",
@@ -705,10 +706,7 @@
                 "spi": {
                     "OpenTelemetry\\API\\Configuration\\ConfigEnv\\EnvComponentLoader": [
                         "OpenTelemetry\\API\\Instrumentation\\Configuration\\General\\ConfigEnv\\EnvComponentLoaderHttpConfig",
-                        "OpenTelemetry\\API\\Instrumentation\\Configuration\\General\\ConfigEnv\\EnvComponentLoaderPeerConfig",
-                        "OpenTelemetry\\SDK\\ConfigEnv\\Trace\\SpanSuppressionStrategySemConv",
-                        "OpenTelemetry\\SDK\\ConfigEnv\\Trace\\SpanSuppressionStrategySpanKind",
-                        "OpenTelemetry\\SDK\\ConfigEnv\\Distribution\\DistributionConfigurationSdk"
+                        "OpenTelemetry\\API\\Instrumentation\\Configuration\\General\\ConfigEnv\\EnvComponentLoaderPeerConfig"
                     ],
                     "OpenTelemetry\\SDK\\Common\\Configuration\\Resolver\\ResolverInterface": [
                         "OpenTelemetry\\SDK\\Common\\Configuration\\Resolver\\SdkConfigurationResolver"
@@ -718,7 +716,7 @@
                     ]
                 },
                 "branch-alias": {
-                    "dev-main": "1.14.x-dev"
+                    "dev-main": "1.12.x-dev"
                 }
             },
             "autoload": {
@@ -761,7 +759,7 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2026-07-14T13:09:54+00:00"
+            "time": "2026-03-21T11:50:01+00:00"
         },
         {
             "name": "open-telemetry/sem-conv",
@@ -820,6 +818,71 @@
             },
             "time": "2026-01-21T04:14:03+00:00"
         },
+        {
+            "name": "opis/closure",
+            "version": "4.5.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/opis/closure.git",
+                "reference": "b97e42b95bb72d87507f5e2d137ceb239aea8d6b"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/opis/closure/zipball/b97e42b95bb72d87507f5e2d137ceb239aea8d6b",
+                "reference": "b97e42b95bb72d87507f5e2d137ceb239aea8d6b",
+                "shasum": ""
+            },
+            "require": {
+                "php": "^8.0"
+            },
+            "require-dev": {
+                "phpunit/phpunit": "^9.0"
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "4.x-dev"
+                }
+            },
+            "autoload": {
+                "files": [
+                    "src/functions.php"
+                ],
+                "psr-4": {
+                    "Opis\\Closure\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Marius Sarca",
+                    "email": "marius.sarca@gmail.com"
+                },
+                {
+                    "name": "Sorin Sarca",
+                    "email": "sarca_sorin@hotmail.com"
+                }
+            ],
+            "description": "A library that can be used to serialize closures (anonymous functions) and arbitrary data.",
+            "homepage": "https://opis.io/closure",
+            "keywords": [
+                "anonymous classes",
+                "anonymous functions",
+                "closure",
+                "function",
+                "serializable",
+                "serialization",
+                "serialize"
+            ],
+            "support": {
+                "issues": "https://github.com/opis/closure/issues",
+                "source": "https://github.com/opis/closure/tree/4.5.0"
+            },
+            "time": "2026-03-05T13:32:42+00:00"
+        },
         {
             "name": "php-http/discovery",
             "version": "1.20.0",
@@ -1240,20 +1303,20 @@
         },
         {
             "name": "ramsey/uuid",
-            "version": "4.9.3",
+            "version": "4.9.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/ramsey/uuid.git",
-                "reference": "1df15849d00943a67d677dc9cfd80795f038c9f8"
+                "reference": "8429c78ca35a09f27565311b98101e2826affde0"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/ramsey/uuid/zipball/1df15849d00943a67d677dc9cfd80795f038c9f8",
-                "reference": "1df15849d00943a67d677dc9cfd80795f038c9f8",
+                "url": "https://api.github.com/repos/ramsey/uuid/zipball/8429c78ca35a09f27565311b98101e2826affde0",
+                "reference": "8429c78ca35a09f27565311b98101e2826affde0",
                 "shasum": ""
             },
             "require": {
-                "brick/math": ">=0.8.16 <=0.18",
+                "brick/math": "^0.8.16 || ^0.9 || ^0.10 || ^0.11 || ^0.12 || ^0.13 || ^0.14",
                 "php": "^8.0",
                 "ramsey/collection": "^1.2 || ^2.0"
             },
@@ -1312,22 +1375,22 @@
             ],
             "support": {
                 "issues": "https://github.com/ramsey/uuid/issues",
-                "source": "https://github.com/ramsey/uuid/tree/4.9.3"
+                "source": "https://github.com/ramsey/uuid/tree/4.9.2"
             },
-            "time": "2026-06-18T03:57:49+00:00"
+            "time": "2025-12-14T04:43:48+00:00"
         },
         {
             "name": "symfony/deprecation-contracts",
-            "version": "v3.7.1",
+            "version": "v3.6.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/deprecation-contracts.git",
-                "reference": "f3202fa1b5097b0af062dc978b32ecf63404e31d"
+                "reference": "63afe740e99a13ba87ec199bb07bbdee937a5b62"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/f3202fa1b5097b0af062dc978b32ecf63404e31d",
-                "reference": "f3202fa1b5097b0af062dc978b32ecf63404e31d",
+                "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/63afe740e99a13ba87ec199bb07bbdee937a5b62",
+                "reference": "63afe740e99a13ba87ec199bb07bbdee937a5b62",
                 "shasum": ""
             },
             "require": {
@@ -1340,7 +1403,7 @@
                     "name": "symfony/contracts"
                 },
                 "branch-alias": {
-                    "dev-main": "3.7-dev"
+                    "dev-main": "3.6-dev"
                 }
             },
             "autoload": {
@@ -1365,7 +1428,7 @@
             "description": "A generic function and convention to trigger deprecation notices",
             "homepage": "https://symfony.com",
             "support": {
-                "source": "https://github.com/symfony/deprecation-contracts/tree/v3.7.1"
+                "source": "https://github.com/symfony/deprecation-contracts/tree/v3.6.0"
             },
             "funding": [
                 {
@@ -1376,29 +1439,25 @@
                     "url": "https://github.com/fabpot",
                     "type": "github"
                 },
-                {
-                    "url": "https://github.com/nicolas-grekas",
-                    "type": "github"
-                },
                 {
                     "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-06-05T06:23:12+00:00"
+            "time": "2024-09-25T14:21:43+00:00"
         },
         {
             "name": "symfony/http-client",
-            "version": "v7.4.16",
+            "version": "v7.4.8",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/http-client.git",
-                "reference": "c513ed0ba5d1784a6b55fc84190dbe4451b12f41"
+                "reference": "01933e626c3de76bea1e22641e205e78f6a34342"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/http-client/zipball/c513ed0ba5d1784a6b55fc84190dbe4451b12f41",
-                "reference": "c513ed0ba5d1784a6b55fc84190dbe4451b12f41",
+                "url": "https://api.github.com/repos/symfony/http-client/zipball/01933e626c3de76bea1e22641e205e78f6a34342",
+                "reference": "01933e626c3de76bea1e22641e205e78f6a34342",
                 "shasum": ""
             },
             "require": {
@@ -1466,7 +1525,7 @@
                 "http"
             ],
             "support": {
-                "source": "https://github.com/symfony/http-client/tree/v7.4.16"
+                "source": "https://github.com/symfony/http-client/tree/v7.4.8"
             },
             "funding": [
                 {
@@ -1486,20 +1545,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-07-29T16:20:51+00:00"
+            "time": "2026-03-30T12:55:43+00:00"
         },
         {
             "name": "symfony/http-client-contracts",
-            "version": "v3.7.1",
+            "version": "v3.6.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/http-client-contracts.git",
-                "reference": "41fc42d276aeff21192465331ebbab7d83a743c0"
+                "reference": "75d7043853a42837e68111812f4d964b01e5101c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/http-client-contracts/zipball/41fc42d276aeff21192465331ebbab7d83a743c0",
-                "reference": "41fc42d276aeff21192465331ebbab7d83a743c0",
+                "url": "https://api.github.com/repos/symfony/http-client-contracts/zipball/75d7043853a42837e68111812f4d964b01e5101c",
+                "reference": "75d7043853a42837e68111812f4d964b01e5101c",
                 "shasum": ""
             },
             "require": {
@@ -1512,7 +1571,7 @@
                     "name": "symfony/contracts"
                 },
                 "branch-alias": {
-                    "dev-main": "3.7-dev"
+                    "dev-main": "3.6-dev"
                 }
             },
             "autoload": {
@@ -1548,7 +1607,7 @@
                 "standards"
             ],
             "support": {
-                "source": "https://github.com/symfony/http-client-contracts/tree/v3.7.1"
+                "source": "https://github.com/symfony/http-client-contracts/tree/v3.6.0"
             },
             "funding": [
                 {
@@ -1559,29 +1618,25 @@
                     "url": "https://github.com/fabpot",
                     "type": "github"
                 },
-                {
-                    "url": "https://github.com/nicolas-grekas",
-                    "type": "github"
-                },
                 {
                     "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-06-05T06:23:12+00:00"
+            "time": "2025-04-29T11:18:49+00:00"
         },
         {
             "name": "symfony/polyfill-mbstring",
-            "version": "v1.38.2",
+            "version": "v1.37.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-mbstring.git",
-                "reference": "d3d318bad5e7a1bfbd026009c8bfb8d8f99ae6b6"
+                "reference": "6a21eb99c6973357967f6ce3708cd55a6bec6315"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/d3d318bad5e7a1bfbd026009c8bfb8d8f99ae6b6",
-                "reference": "d3d318bad5e7a1bfbd026009c8bfb8d8f99ae6b6",
+                "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/6a21eb99c6973357967f6ce3708cd55a6bec6315",
+                "reference": "6a21eb99c6973357967f6ce3708cd55a6bec6315",
                 "shasum": ""
             },
             "require": {
@@ -1633,7 +1688,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-mbstring/tree/v1.38.2"
+                "source": "https://github.com/symfony/polyfill-mbstring/tree/v1.37.0"
             },
             "funding": [
                 {
@@ -1653,20 +1708,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-05-27T06:59:30+00:00"
+            "time": "2026-04-10T17:25:58+00:00"
         },
         {
             "name": "symfony/polyfill-php82",
-            "version": "v1.38.1",
+            "version": "v1.37.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-php82.git",
-                "reference": "002dc0cfe5fd4ed6033d48f27d4f19a486c4b04b"
+                "reference": "34808efe3e68f69685796f7c253a2f1d8ea9df59"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/polyfill-php82/zipball/002dc0cfe5fd4ed6033d48f27d4f19a486c4b04b",
-                "reference": "002dc0cfe5fd4ed6033d48f27d4f19a486c4b04b",
+                "url": "https://api.github.com/repos/symfony/polyfill-php82/zipball/34808efe3e68f69685796f7c253a2f1d8ea9df59",
+                "reference": "34808efe3e68f69685796f7c253a2f1d8ea9df59",
                 "shasum": ""
             },
             "require": {
@@ -1713,7 +1768,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-php82/tree/v1.38.1"
+                "source": "https://github.com/symfony/polyfill-php82/tree/v1.37.0"
             },
             "funding": [
                 {
@@ -1733,20 +1788,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-05-26T12:45:58+00:00"
+            "time": "2026-04-10T16:19:22+00:00"
         },
         {
             "name": "symfony/polyfill-php83",
-            "version": "v1.41.0",
+            "version": "v1.37.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-php83.git",
-                "reference": "5ea99087fb99c273a9b9236ed4c31e78b16103c6"
+                "reference": "3600c2cb22399e25bb226e4a135ce91eeb2a6149"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/polyfill-php83/zipball/5ea99087fb99c273a9b9236ed4c31e78b16103c6",
-                "reference": "5ea99087fb99c273a9b9236ed4c31e78b16103c6",
+                "url": "https://api.github.com/repos/symfony/polyfill-php83/zipball/3600c2cb22399e25bb226e4a135ce91eeb2a6149",
+                "reference": "3600c2cb22399e25bb226e4a135ce91eeb2a6149",
                 "shasum": ""
             },
             "require": {
@@ -1793,7 +1848,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-php83/tree/v1.41.0"
+                "source": "https://github.com/symfony/polyfill-php83/tree/v1.37.0"
             },
             "funding": [
                 {
@@ -1813,20 +1868,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-07-01T12:47:55+00:00"
+            "time": "2026-04-10T17:25:58+00:00"
         },
         {
             "name": "symfony/polyfill-php85",
-            "version": "v1.41.0",
+            "version": "v1.37.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-php85.git",
-                "reference": "255fab485aaa1006ed411040c42aecd7b5302d7a"
+                "reference": "fcfa4973a9917cef23f2e38774da74a2b7d115ee"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/polyfill-php85/zipball/255fab485aaa1006ed411040c42aecd7b5302d7a",
-                "reference": "255fab485aaa1006ed411040c42aecd7b5302d7a",
+                "url": "https://api.github.com/repos/symfony/polyfill-php85/zipball/fcfa4973a9917cef23f2e38774da74a2b7d115ee",
+                "reference": "fcfa4973a9917cef23f2e38774da74a2b7d115ee",
                 "shasum": ""
             },
             "require": {
@@ -1873,7 +1928,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-php85/tree/v1.41.0"
+                "source": "https://github.com/symfony/polyfill-php85/tree/v1.37.0"
             },
             "funding": [
                 {
@@ -1893,20 +1948,20 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-07-01T12:47:55+00:00"
+            "time": "2026-04-26T13:10:57+00:00"
         },
         {
             "name": "symfony/service-contracts",
-            "version": "v3.7.1",
+            "version": "v3.6.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/service-contracts.git",
-                "reference": "c0a284bab1ed8aa0417e3d69250ab437739563a0"
+                "reference": "45112560a3ba2d715666a509a0bc9521d10b6c43"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/service-contracts/zipball/c0a284bab1ed8aa0417e3d69250ab437739563a0",
-                "reference": "c0a284bab1ed8aa0417e3d69250ab437739563a0",
+                "url": "https://api.github.com/repos/symfony/service-contracts/zipball/45112560a3ba2d715666a509a0bc9521d10b6c43",
+                "reference": "45112560a3ba2d715666a509a0bc9521d10b6c43",
                 "shasum": ""
             },
             "require": {
@@ -1924,7 +1979,7 @@
                     "name": "symfony/contracts"
                 },
                 "branch-alias": {
-                    "dev-main": "3.7-dev"
+                    "dev-main": "3.6-dev"
                 }
             },
             "autoload": {
@@ -1960,7 +2015,7 @@
                 "standards"
             ],
             "support": {
-                "source": "https://github.com/symfony/service-contracts/tree/v3.7.1"
+                "source": "https://github.com/symfony/service-contracts/tree/v3.6.1"
             },
             "funding": [
                 {
@@ -1980,7 +2035,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-06-16T09:55:08+00:00"
+            "time": "2025-07-15T11:30:57+00:00"
         },
         {
             "name": "tbachert/spi",
@@ -2034,24 +2089,142 @@
             },
             "time": "2025-06-29T15:42:06+00:00"
         },
+        {
+            "name": "utopia-php/async",
+            "version": "0.1.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/utopia-php/async.git",
+                "reference": "3ee4fc3d505113d0d6050f35f5bf85e706866a22"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/utopia-php/async/zipball/3ee4fc3d505113d0d6050f35f5bf85e706866a22",
+                "reference": "3ee4fc3d505113d0d6050f35f5bf85e706866a22",
+                "shasum": ""
+            },
+            "require": {
+                "opis/closure": "4.*",
+                "php": ">=8.1"
+            },
+            "require-dev": {
+                "amphp/amp": "3.*",
+                "amphp/parallel": "2.*",
+                "amphp/process": "^2.0",
+                "laravel/pint": "1.*",
+                "phpstan/phpstan": "2.*",
+                "phpunit/phpunit": "11.5.45",
+                "react/child-process": "0.*",
+                "react/event-loop": "1.*",
+                "swoole/ide-helper": "*"
+            },
+            "suggest": {
+                "amphp/amp": "Required for Amp promise adapter",
+                "amphp/parallel": "Required for Amp parallel adapter",
+                "ext-ev": "Required for ReactPHP event loop (recommended for best performance)",
+                "ext-parallel": "Required for parallel adapter (requires PHP ZTS build)",
+                "ext-sockets": "Required for Swoole Process adapter",
+                "ext-swoole": "Required for Swoole Thread and Process adapters (recommended for best performance)",
+                "react/child-process": "Required for ReactPHP parallel adapter",
+                "react/event-loop": "Required for ReactPHP promise and parallel adapters"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Utopia\\Async\\": "src/"
+                }
+            },
+            "autoload-dev": {
+                "psr-4": {
+                    "Utopia\\Tests\\": "tests/"
+                }
+            },
+            "scripts": {
+                "test-unit": [
+                    "vendor/bin/phpunit tests/Unit --exclude-group no-swoole"
+                ],
+                "test-promise-sync": [
+                    "vendor/bin/phpunit tests/E2e/Promise/SyncTest.php"
+                ],
+                "test-promise-swoole": [
+                    "vendor/bin/phpunit tests/E2e/Promise/Swoole"
+                ],
+                "test-promise-amp": [
+                    "vendor/bin/phpunit tests/E2e/Promise/Amp"
+                ],
+                "test-promise-react": [
+                    "vendor/bin/phpunit tests/E2e/Promise/React"
+                ],
+                "test-parallel-sync": [
+                    "vendor/bin/phpunit tests/E2e/Parallel/Sync"
+                ],
+                "test-parallel-swoole-thread": [
+                    "vendor/bin/phpunit tests/E2e/Parallel/Swoole/ThreadTest.php"
+                ],
+                "test-parallel-swoole-process": [
+                    "vendor/bin/phpunit tests/E2e/Parallel/Swoole/ProcessTest.php"
+                ],
+                "test-parallel-amp": [
+                    "vendor/bin/phpunit tests/E2e/Parallel/Amp"
+                ],
+                "test-parallel-react": [
+                    "vendor/bin/phpunit tests/E2e/Parallel/React"
+                ],
+                "test-parallel-ext": [
+                    "php -n -d extension=parallel.so -d extension=sockets.so vendor/bin/phpunit tests/E2e/Parallel/Parallel"
+                ],
+                "test-e2e": [
+                    "vendor/bin/phpunit tests/E2e --exclude-group ext-parallel"
+                ],
+                "test": [
+                    "@test-unit",
+                    "@test-e2e",
+                    "@test-parallel-ext"
+                ],
+                "lint": [
+                    "vendor/bin/pint"
+                ],
+                "format": [
+                    "php -d memory_limit=4G vendor/bin/pint"
+                ],
+                "check": [
+                    "vendor/bin/phpstan analyse src tests --level=max --memory-limit=4G"
+                ]
+            },
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Appwrite Team",
+                    "email": "team@appwrite.io"
+                }
+            ],
+            "description": "High-performance concurrent + parallel library with Promise and Parallel execution support for PHP.",
+            "support": {
+                "source": "https://github.com/utopia-php/async/tree/0.1.1",
+                "issues": "https://github.com/utopia-php/async/issues"
+            },
+            "time": "2026-06-08T05:10:34+00:00"
+        },
         {
             "name": "utopia-php/cache",
-            "version": "5.0.0",
+            "version": "4.0.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/cache.git",
-                "reference": "0d0752785fc81b5afd6571f4291763166a6532bc"
+                "reference": "92e02dab63606234b993b841ebf4c58845dd4620"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/cache/zipball/0d0752785fc81b5afd6571f4291763166a6532bc",
-                "reference": "0d0752785fc81b5afd6571f4291763166a6532bc",
+                "url": "https://api.github.com/repos/utopia-php/cache/zipball/92e02dab63606234b993b841ebf4c58845dd4620",
+                "reference": "92e02dab63606234b993b841ebf4c58845dd4620",
                 "shasum": ""
             },
             "require": {
                 "ext-json": "*",
                 "php": ">=8.4",
-                "utopia-php/circuit-breaker": "^0.4",
+                "utopia-php/circuit-breaker": "^0.3",
                 "utopia-php/pools": "^2.0",
                 "utopia-php/telemetry": "^0.4"
             },
@@ -2089,22 +2262,22 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/cache/issues",
-                "source": "https://github.com/utopia-php/cache/tree/5.0.0"
+                "source": "https://github.com/utopia-php/cache/tree/4.0.2"
             },
-            "time": "2026-08-21T11:04:48+00:00"
+            "time": "2026-08-12T07:48:59+00:00"
         },
         {
             "name": "utopia-php/circuit-breaker",
-            "version": "0.4.0",
+            "version": "0.3.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/circuit-breaker.git",
-                "reference": "c6d93c7ba9d895cf906360e000f74ff762d83e17"
+                "reference": "5fbc3802471b0d1b4260bd9f5544514e6929b481"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/circuit-breaker/zipball/c6d93c7ba9d895cf906360e000f74ff762d83e17",
-                "reference": "c6d93c7ba9d895cf906360e000f74ff762d83e17",
+                "url": "https://api.github.com/repos/utopia-php/circuit-breaker/zipball/5fbc3802471b0d1b4260bd9f5544514e6929b481",
+                "reference": "5fbc3802471b0d1b4260bd9f5544514e6929b481",
                 "shasum": ""
             },
             "require": {
@@ -2148,9 +2321,9 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/circuit-breaker/issues",
-                "source": "https://github.com/utopia-php/circuit-breaker/tree/0.4.0"
+                "source": "https://github.com/utopia-php/circuit-breaker/tree/0.3.2"
             },
-            "time": "2026-08-21T10:20:24+00:00"
+            "time": "2026-08-05T18:07:20+00:00"
         },
         {
             "name": "utopia-php/console",
@@ -2317,6 +2490,86 @@
             },
             "time": "2026-08-05T18:07:20+00:00"
         },
+        {
+            "name": "utopia-php/query",
+            "version": "0.6.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/utopia-php/query.git",
+                "reference": "abaebb2f3426bdbc6f44bab04254a668de937148"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/utopia-php/query/zipball/abaebb2f3426bdbc6f44bab04254a668de937148",
+                "reference": "abaebb2f3426bdbc6f44bab04254a668de937148",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4"
+            },
+            "require-dev": {
+                "brianium/paratest": "*",
+                "laravel/pint": "*",
+                "mongodb/mongodb": "^2.0",
+                "phpstan/phpstan": "*",
+                "phpunit/phpcov": "*",
+                "phpunit/phpunit": "^12.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Utopia\\Query\\": "src/Query"
+                }
+            },
+            "autoload-dev": {
+                "psr-4": {
+                    "Tests\\Query\\": "tests/Query",
+                    "Tests\\Integration\\": "tests/Integration"
+                }
+            },
+            "scripts": {
+                "test": [
+                    "vendor/bin/paratest --testsuite Query --processes=auto --exclude-group=performance"
+                ],
+                "test:coverage": [
+                    "vendor/bin/paratest --testsuite Query --processes=auto --exclude-group=performance --coverage-php coverage/unit.cov"
+                ],
+                "test:performance": [
+                    "vendor/bin/phpunit --testsuite Query --group=performance"
+                ],
+                "test:integration": [
+                    "vendor/bin/phpunit --testsuite Integration"
+                ],
+                "test:integration:coverage": [
+                    "vendor/bin/phpunit --testsuite Integration --coverage-php coverage/integration.cov"
+                ],
+                "lint": [
+                    "php -d memory_limit=2G ./vendor/bin/pint --test"
+                ],
+                "format": [
+                    "php -d memory_limit=2G ./vendor/bin/pint"
+                ],
+                "check": [
+                    "./vendor/bin/phpstan analyse --level max src tests --memory-limit 2G"
+                ]
+            },
+            "license": [
+                "MIT"
+            ],
+            "description": "A simple library providing a query abstraction for filtering, ordering, and pagination",
+            "keywords": [
+                "framework",
+                "php",
+                "query",
+                "upf",
+                "utopia"
+            ],
+            "support": {
+                "source": "https://github.com/utopia-php/query/tree/0.6.0",
+                "issues": "https://github.com/utopia-php/query/issues"
+            },
+            "time": "2026-08-21T11:03:36+00:00"
+        },
         {
             "name": "utopia-php/telemetry",
             "version": "0.4.6",
@@ -2411,35 +2664,56 @@
     ],
     "packages-dev": [
         {
-            "name": "doctrine/instantiator",
-            "version": "2.1.0",
+            "name": "brianium/paratest",
+            "version": "v7.20.0",
             "source": {
                 "type": "git",
-                "url": "https://github.com/doctrine/instantiator.git",
-                "reference": "23da848e1a2308728fe5fdddabf4be17ff9720c7"
+                "url": "https://github.com/paratestphp/paratest.git",
+                "reference": "81c80677c9ec0ed4ef16b246167f11dec81a6e3d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/doctrine/instantiator/zipball/23da848e1a2308728fe5fdddabf4be17ff9720c7",
-                "reference": "23da848e1a2308728fe5fdddabf4be17ff9720c7",
+                "url": "https://api.github.com/repos/paratestphp/paratest/zipball/81c80677c9ec0ed4ef16b246167f11dec81a6e3d",
+                "reference": "81c80677c9ec0ed4ef16b246167f11dec81a6e3d",
                 "shasum": ""
             },
             "require": {
-                "php": "^8.4"
+                "ext-dom": "*",
+                "ext-pcre": "*",
+                "ext-reflection": "*",
+                "ext-simplexml": "*",
+                "fidry/cpu-core-counter": "^1.3.0",
+                "jean85/pretty-package-versions": "^2.1.1",
+                "php": "~8.3.0 || ~8.4.0 || ~8.5.0",
+                "phpunit/php-code-coverage": "^12.5.3 || ^13.0.1",
+                "phpunit/php-file-iterator": "^6.0.1 || ^7",
+                "phpunit/php-timer": "^8 || ^9",
+                "phpunit/phpunit": "^12.5.14 || ^13.0.5",
+                "sebastian/environment": "^8.0.3 || ^9",
+                "symfony/console": "^7.4.7 || ^8.0.7",
+                "symfony/process": "^7.4.5 || ^8.0.5"
             },
             "require-dev": {
-                "doctrine/coding-standard": "^14",
-                "ext-pdo": "*",
-                "ext-phar": "*",
-                "phpbench/phpbench": "^1.2",
-                "phpstan/phpstan": "^2.1",
-                "phpstan/phpstan-phpunit": "^2.0",
-                "phpunit/phpunit": "^10.5.58"
+                "doctrine/coding-standard": "^14.0.0",
+                "ext-pcntl": "*",
+                "ext-pcov": "*",
+                "ext-posix": "*",
+                "phpstan/phpstan": "^2.1.44",
+                "phpstan/phpstan-deprecation-rules": "^2.0.4",
+                "phpstan/phpstan-phpunit": "^2.0.16",
+                "phpstan/phpstan-strict-rules": "^2.0.10",
+                "symfony/filesystem": "^7.4.6 || ^8.0.6"
             },
+            "bin": [
+                "bin/paratest",
+                "bin/paratest_for_phpstorm"
+            ],
             "type": "library",
             "autoload": {
                 "psr-4": {
-                    "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
+                    "ParaTest\\": [
+                        "src/"
+                    ]
                 }
             },
             "notification-url": "https://packagist.org/downloads/",
@@ -2448,36 +2722,39 @@
             ],
             "authors": [
                 {
-                    "name": "Marco Pivetta",
-                    "email": "ocramius@gmail.com",
-                    "homepage": "https://ocramius.github.io/"
+                    "name": "Brian Scaturro",
+                    "email": "scaturrob@gmail.com",
+                    "role": "Developer"
+                },
+                {
+                    "name": "Filippo Tessarotto",
+                    "email": "zoeslam@gmail.com",
+                    "role": "Developer"
                 }
             ],
-            "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
-            "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
+            "description": "Parallel testing for PHP",
+            "homepage": "https://github.com/paratestphp/paratest",
             "keywords": [
-                "constructor",
-                "instantiate"
+                "concurrent",
+                "parallel",
+                "phpunit",
+                "testing"
             ],
             "support": {
-                "issues": "https://github.com/doctrine/instantiator/issues",
-                "source": "https://github.com/doctrine/instantiator/tree/2.1.0"
+                "issues": "https://github.com/paratestphp/paratest/issues",
+                "source": "https://github.com/paratestphp/paratest/tree/v7.20.0"
             },
             "funding": [
                 {
-                    "url": "https://www.doctrine-project.org/sponsorship.html",
-                    "type": "custom"
-                },
-                {
-                    "url": "https://www.patreon.com/phpdoctrine",
-                    "type": "patreon"
+                    "url": "https://github.com/sponsors/Slamdunk",
+                    "type": "github"
                 },
                 {
-                    "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator",
-                    "type": "tidelift"
+                    "url": "https://paypal.me/filippotessarotto",
+                    "type": "paypal"
                 }
             ],
-            "time": "2026-01-05T06:47:08+00:00"
+            "time": "2026-03-29T15:46:14+00:00"
         },
         {
             "name": "fakerphp/faker",
@@ -2542,18 +2819,139 @@
             },
             "time": "2024-01-02T13:46:09+00:00"
         },
+        {
+            "name": "fidry/cpu-core-counter",
+            "version": "1.3.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/theofidry/cpu-core-counter.git",
+                "reference": "db9508f7b1474469d9d3c53b86f817e344732678"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/theofidry/cpu-core-counter/zipball/db9508f7b1474469d9d3c53b86f817e344732678",
+                "reference": "db9508f7b1474469d9d3c53b86f817e344732678",
+                "shasum": ""
+            },
+            "require": {
+                "php": "^7.2 || ^8.0"
+            },
+            "require-dev": {
+                "fidry/makefile": "^0.2.0",
+                "fidry/php-cs-fixer-config": "^1.1.2",
+                "phpstan/extension-installer": "^1.2.0",
+                "phpstan/phpstan": "^2.0",
+                "phpstan/phpstan-deprecation-rules": "^2.0.0",
+                "phpstan/phpstan-phpunit": "^2.0",
+                "phpstan/phpstan-strict-rules": "^2.0",
+                "phpunit/phpunit": "^8.5.31 || ^9.5.26",
+                "webmozarts/strict-phpunit": "^7.5"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Fidry\\CpuCoreCounter\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Théo FIDRY",
+                    "email": "theo.fidry@gmail.com"
+                }
+            ],
+            "description": "Tiny utility to get the number of CPU cores.",
+            "keywords": [
+                "CPU",
+                "core"
+            ],
+            "support": {
+                "issues": "https://github.com/theofidry/cpu-core-counter/issues",
+                "source": "https://github.com/theofidry/cpu-core-counter/tree/1.3.0"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/theofidry",
+                    "type": "github"
+                }
+            ],
+            "time": "2025-08-14T07:29:31+00:00"
+        },
+        {
+            "name": "jean85/pretty-package-versions",
+            "version": "2.1.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/Jean85/pretty-package-versions.git",
+                "reference": "4d7aa5dab42e2a76d99559706022885de0e18e1a"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/Jean85/pretty-package-versions/zipball/4d7aa5dab42e2a76d99559706022885de0e18e1a",
+                "reference": "4d7aa5dab42e2a76d99559706022885de0e18e1a",
+                "shasum": ""
+            },
+            "require": {
+                "composer-runtime-api": "^2.1.0",
+                "php": "^7.4|^8.0"
+            },
+            "require-dev": {
+                "friendsofphp/php-cs-fixer": "^3.2",
+                "jean85/composer-provided-replaced-stub-package": "^1.0",
+                "phpstan/phpstan": "^2.0",
+                "phpunit/phpunit": "^7.5|^8.5|^9.6",
+                "rector/rector": "^2.0",
+                "vimeo/psalm": "^4.3 || ^5.0"
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "1.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Jean85\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Alessandro Lai",
+                    "email": "alessandro.lai85@gmail.com"
+                }
+            ],
+            "description": "A library to get pretty versions strings of installed dependencies",
+            "keywords": [
+                "composer",
+                "package",
+                "release",
+                "versions"
+            ],
+            "support": {
+                "issues": "https://github.com/Jean85/pretty-package-versions/issues",
+                "source": "https://github.com/Jean85/pretty-package-versions/tree/2.1.1"
+            },
+            "time": "2025-03-19T14:43:43+00:00"
+        },
         {
             "name": "laravel/pint",
-            "version": "v1.30.4",
+            "version": "v1.29.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/pint.git",
-                "reference": "a96cb6eee2961905d2fce7207aefb80945bf6b28"
+                "reference": "0770e9b7fafd50d4586881d456d6eb41c9247a80"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/pint/zipball/a96cb6eee2961905d2fce7207aefb80945bf6b28",
-                "reference": "a96cb6eee2961905d2fce7207aefb80945bf6b28",
+                "url": "https://api.github.com/repos/laravel/pint/zipball/0770e9b7fafd50d4586881d456d6eb41c9247a80",
+                "reference": "0770e9b7fafd50d4586881d456d6eb41c9247a80",
                 "shasum": ""
             },
             "require": {
@@ -2564,16 +2962,14 @@
                 "php": "^8.2.0"
             },
             "require-dev": {
-                "composer/semver": "^3.4.4",
-                "friendsofphp/php-cs-fixer": "^3.95.18",
-                "illuminate/view": "^12.65.0",
-                "larastan/larastan": "^3.10.0",
+                "friendsofphp/php-cs-fixer": "^3.95.1",
+                "illuminate/view": "^12.56.0",
+                "larastan/larastan": "^3.9.6",
                 "laravel-zero/framework": "^12.1.0",
-                "laravel/agent-detector": "^2.0.2",
-                "laravel/prompts": "^0.3.22",
                 "mockery/mockery": "^1.6.12",
                 "nunomaduro/termwind": "^2.4.0",
-                "pestphp/pest": "^3.8.7"
+                "pestphp/pest": "^3.8.6",
+                "shipfastlabs/agent-detector": "^1.1.3"
             },
             "bin": [
                 "builds/pint"
@@ -2610,7 +3006,7 @@
                 "issues": "https://github.com/laravel/pint/issues",
                 "source": "https://github.com/laravel/pint"
             },
-            "time": "2026-08-05T16:47:22+00:00"
+            "time": "2026-04-20T15:26:14+00:00"
         },
         {
             "name": "myclabs/deep-copy",
@@ -2674,30 +3070,37 @@
         },
         {
             "name": "nikic/php-parser",
-            "version": "v4.19.5",
+            "version": "v5.7.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/nikic/PHP-Parser.git",
-                "reference": "51bd93cc741b7fc3d63d20b6bdcd99fdaa359837"
+                "reference": "dca41cd15c2ac9d055ad70dbfd011130757d1f82"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/51bd93cc741b7fc3d63d20b6bdcd99fdaa359837",
-                "reference": "51bd93cc741b7fc3d63d20b6bdcd99fdaa359837",
+                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/dca41cd15c2ac9d055ad70dbfd011130757d1f82",
+                "reference": "dca41cd15c2ac9d055ad70dbfd011130757d1f82",
                 "shasum": ""
             },
             "require": {
+                "ext-ctype": "*",
+                "ext-json": "*",
                 "ext-tokenizer": "*",
-                "php": ">=7.1"
+                "php": ">=7.4"
             },
             "require-dev": {
                 "ircmaxell/php-yacc": "^0.0.7",
-                "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0"
+                "phpunit/phpunit": "^9.0"
             },
             "bin": [
                 "bin/php-parse"
             ],
             "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "5.x-dev"
+                }
+            },
             "autoload": {
                 "psr-4": {
                     "PhpParser\\": "lib/PhpParser"
@@ -2719,56 +3122,22 @@
             ],
             "support": {
                 "issues": "https://github.com/nikic/PHP-Parser/issues",
-                "source": "https://github.com/nikic/PHP-Parser/tree/v4.19.5"
+                "source": "https://github.com/nikic/PHP-Parser/tree/v5.7.0"
             },
-            "time": "2025-12-06T11:45:25+00:00"
+            "time": "2025-12-06T11:56:16+00:00"
         },
         {
-            "name": "pcov/clobber",
-            "version": "v2.0.3",
+            "name": "phar-io/manifest",
+            "version": "2.0.4",
             "source": {
                 "type": "git",
-                "url": "https://github.com/krakjoe/pcov-clobber.git",
-                "reference": "4c30759e912e6e5d5bf833fb3d77b5bd51709f05"
+                "url": "https://github.com/phar-io/manifest.git",
+                "reference": "54750ef60c58e43759730615a392c31c80e23176"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/krakjoe/pcov-clobber/zipball/4c30759e912e6e5d5bf833fb3d77b5bd51709f05",
-                "reference": "4c30759e912e6e5d5bf833fb3d77b5bd51709f05",
-                "shasum": ""
-            },
-            "require": {
-                "ext-pcov": "^1.0",
-                "nikic/php-parser": "^4.2"
-            },
-            "bin": [
-                "bin/pcov"
-            ],
-            "type": "library",
-            "autoload": {
-                "psr-4": {
-                    "pcov\\Clobber\\": "src/pcov/clobber"
-                }
-            },
-            "notification-url": "https://packagist.org/downloads/",
-            "support": {
-                "issues": "https://github.com/krakjoe/pcov-clobber/issues",
-                "source": "https://github.com/krakjoe/pcov-clobber/tree/v2.0.3"
-            },
-            "time": "2019-10-29T05:03:37+00:00"
-        },
-        {
-            "name": "phar-io/manifest",
-            "version": "2.0.4",
-            "source": {
-                "type": "git",
-                "url": "https://github.com/phar-io/manifest.git",
-                "reference": "54750ef60c58e43759730615a392c31c80e23176"
-            },
-            "dist": {
-                "type": "zip",
-                "url": "https://api.github.com/repos/phar-io/manifest/zipball/54750ef60c58e43759730615a392c31c80e23176",
-                "reference": "54750ef60c58e43759730615a392c31c80e23176",
+                "url": "https://api.github.com/repos/phar-io/manifest/zipball/54750ef60c58e43759730615a392c31c80e23176",
+                "reference": "54750ef60c58e43759730615a392c31c80e23176",
                 "shasum": ""
             },
             "require": {
@@ -2877,15 +3246,15 @@
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.12.34",
+            "version": "2.1.54",
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/4dd89ca7aa30fdc6760be21550d583bcc32e8476",
-                "reference": "4dd89ca7aa30fdc6760be21550d583bcc32e8476",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/8be50c3992107dc837b17da4d140fbbdf9a5c5bd",
+                "reference": "8be50c3992107dc837b17da4d140fbbdf9a5c5bd",
                 "shasum": ""
             },
             "require": {
-                "php": "^7.2|^8.0"
+                "php": "^7.4|^8.0"
             },
             "conflict": {
                 "phpstan/phpstan-shim": "*"
@@ -2926,39 +3295,93 @@
                     "type": "github"
                 }
             ],
-            "time": "2026-07-28T10:04:39+00:00"
+            "time": "2026-04-29T13:31:09+00:00"
+        },
+        {
+            "name": "phpstan/phpstan-phpunit",
+            "version": "2.0.16",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/phpstan/phpstan-phpunit.git",
+                "reference": "6ab598e1bc106e6827fd346ae4a12b4a5d634c32"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/phpstan/phpstan-phpunit/zipball/6ab598e1bc106e6827fd346ae4a12b4a5d634c32",
+                "reference": "6ab598e1bc106e6827fd346ae4a12b4a5d634c32",
+                "shasum": ""
+            },
+            "require": {
+                "php": "^7.4 || ^8.0",
+                "phpstan/phpstan": "^2.1.32"
+            },
+            "conflict": {
+                "phpunit/phpunit": "<7.0"
+            },
+            "require-dev": {
+                "nikic/php-parser": "^5",
+                "php-parallel-lint/php-parallel-lint": "^1.2",
+                "phpstan/phpstan-deprecation-rules": "^2.0",
+                "phpstan/phpstan-strict-rules": "^2.0",
+                "phpunit/phpunit": "^9.6"
+            },
+            "type": "phpstan-extension",
+            "extra": {
+                "phpstan": {
+                    "includes": [
+                        "extension.neon",
+                        "rules.neon"
+                    ]
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "PHPStan\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "description": "PHPUnit extensions and rules for PHPStan",
+            "keywords": [
+                "static analysis"
+            ],
+            "support": {
+                "issues": "https://github.com/phpstan/phpstan-phpunit/issues",
+                "source": "https://github.com/phpstan/phpstan-phpunit/tree/2.0.16"
+            },
+            "time": "2026-02-14T09:05:21+00:00"
         },
         {
             "name": "phpunit/php-code-coverage",
-            "version": "9.2.32",
+            "version": "12.5.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
-                "reference": "85402a822d1ecf1db1096959413d35e1c37cf1a5"
+                "reference": "876099a072646c7745f673d7aeab5382c4439691"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/85402a822d1ecf1db1096959413d35e1c37cf1a5",
-                "reference": "85402a822d1ecf1db1096959413d35e1c37cf1a5",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/876099a072646c7745f673d7aeab5382c4439691",
+                "reference": "876099a072646c7745f673d7aeab5382c4439691",
                 "shasum": ""
             },
             "require": {
                 "ext-dom": "*",
                 "ext-libxml": "*",
                 "ext-xmlwriter": "*",
-                "nikic/php-parser": "^4.19.1 || ^5.1.0",
-                "php": ">=7.3",
-                "phpunit/php-file-iterator": "^3.0.6",
-                "phpunit/php-text-template": "^2.0.4",
-                "sebastian/code-unit-reverse-lookup": "^2.0.3",
-                "sebastian/complexity": "^2.0.3",
-                "sebastian/environment": "^5.1.5",
-                "sebastian/lines-of-code": "^1.0.4",
-                "sebastian/version": "^3.0.2",
-                "theseer/tokenizer": "^1.2.3"
+                "nikic/php-parser": "^5.7.0",
+                "php": ">=8.3",
+                "phpunit/php-text-template": "^5.0",
+                "sebastian/complexity": "^5.0",
+                "sebastian/environment": "^8.0.3",
+                "sebastian/lines-of-code": "^4.0",
+                "sebastian/version": "^6.0",
+                "theseer/tokenizer": "^2.0.1"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.6"
+                "phpunit/phpunit": "^12.5.1"
             },
             "suggest": {
                 "ext-pcov": "PHP extension that provides line coverage",
@@ -2967,7 +3390,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "9.2.x-dev"
+                    "dev-main": "12.5.x-dev"
                 }
             },
             "autoload": {
@@ -2996,40 +3419,52 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
                 "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy",
-                "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/9.2.32"
+                "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/12.5.6"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
+                },
+                {
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/phpunit/php-code-coverage",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2024-08-22T04:23:01+00:00"
+            "time": "2026-04-15T08:23:17+00:00"
         },
         {
             "name": "phpunit/php-file-iterator",
-            "version": "3.0.6",
+            "version": "6.0.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
-                "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf"
+                "reference": "3d1cd096ef6bea4bf2762ba586e35dbd317cbfd5"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
-                "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/3d1cd096ef6bea4bf2762ba586e35dbd317cbfd5",
+                "reference": "3d1cd096ef6bea4bf2762ba586e35dbd317cbfd5",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "3.0-dev"
+                    "dev-main": "6.0-dev"
                 }
             },
             "autoload": {
@@ -3056,36 +3491,49 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues",
-                "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/3.0.6"
+                "security": "https://github.com/sebastianbergmann/php-file-iterator/security/policy",
+                "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/6.0.1"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
+                },
+                {
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/phpunit/php-file-iterator",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2021-12-02T12:48:52+00:00"
+            "time": "2026-02-02T14:04:18+00:00"
         },
         {
             "name": "phpunit/php-invoker",
-            "version": "3.1.1",
+            "version": "6.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-invoker.git",
-                "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67"
+                "reference": "12b54e689b07a25a9b41e57736dfab6ec9ae5406"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
-                "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/12b54e689b07a25a9b41e57736dfab6ec9ae5406",
+                "reference": "12b54e689b07a25a9b41e57736dfab6ec9ae5406",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
                 "ext-pcntl": "*",
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "suggest": {
                 "ext-pcntl": "*"
@@ -3093,7 +3541,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "3.1-dev"
+                    "dev-main": "6.0-dev"
                 }
             },
             "autoload": {
@@ -3119,7 +3567,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-invoker/issues",
-                "source": "https://github.com/sebastianbergmann/php-invoker/tree/3.1.1"
+                "security": "https://github.com/sebastianbergmann/php-invoker/security/policy",
+                "source": "https://github.com/sebastianbergmann/php-invoker/tree/6.0.0"
             },
             "funding": [
                 {
@@ -3127,32 +3576,32 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-09-28T05:58:55+00:00"
+            "time": "2025-02-07T04:58:58+00:00"
         },
         {
             "name": "phpunit/php-text-template",
-            "version": "2.0.4",
+            "version": "5.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-text-template.git",
-                "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28"
+                "reference": "e1367a453f0eda562eedb4f659e13aa900d66c53"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
-                "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/e1367a453f0eda562eedb4f659e13aa900d66c53",
+                "reference": "e1367a453f0eda562eedb4f659e13aa900d66c53",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "2.0-dev"
+                    "dev-main": "5.0-dev"
                 }
             },
             "autoload": {
@@ -3178,7 +3627,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-text-template/issues",
-                "source": "https://github.com/sebastianbergmann/php-text-template/tree/2.0.4"
+                "security": "https://github.com/sebastianbergmann/php-text-template/security/policy",
+                "source": "https://github.com/sebastianbergmann/php-text-template/tree/5.0.0"
             },
             "funding": [
                 {
@@ -3186,32 +3636,32 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-10-26T05:33:50+00:00"
+            "time": "2025-02-07T04:59:16+00:00"
         },
         {
             "name": "phpunit/php-timer",
-            "version": "5.0.3",
+            "version": "8.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-timer.git",
-                "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2"
+                "reference": "f258ce36aa457f3aa3339f9ed4c81fc66dc8c2cc"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
-                "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
+                "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/f258ce36aa457f3aa3339f9ed4c81fc66dc8c2cc",
+                "reference": "f258ce36aa457f3aa3339f9ed4c81fc66dc8c2cc",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "5.0-dev"
+                    "dev-main": "8.0-dev"
                 }
             },
             "autoload": {
@@ -3237,7 +3687,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/php-timer/issues",
-                "source": "https://github.com/sebastianbergmann/php-timer/tree/5.0.3"
+                "security": "https://github.com/sebastianbergmann/php-timer/security/policy",
+                "source": "https://github.com/sebastianbergmann/php-timer/tree/8.0.0"
             },
             "funding": [
                 {
@@ -3245,54 +3696,49 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-10-26T13:16:10+00:00"
+            "time": "2025-02-07T04:59:38+00:00"
         },
         {
             "name": "phpunit/phpunit",
-            "version": "9.6.35",
+            "version": "12.5.23",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "0edba2f3a0c48df3553cb9b640810b30df60302b"
+                "reference": "c54fcf3d6bcb6e96ac2f7e40097dc37b5f139969"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/0edba2f3a0c48df3553cb9b640810b30df60302b",
-                "reference": "0edba2f3a0c48df3553cb9b640810b30df60302b",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/c54fcf3d6bcb6e96ac2f7e40097dc37b5f139969",
+                "reference": "c54fcf3d6bcb6e96ac2f7e40097dc37b5f139969",
                 "shasum": ""
             },
             "require": {
-                "doctrine/instantiator": "^1.5.0 || ^2",
                 "ext-dom": "*",
-                "ext-filter": "*",
                 "ext-json": "*",
                 "ext-libxml": "*",
                 "ext-mbstring": "*",
+                "ext-xml": "*",
                 "ext-xmlwriter": "*",
                 "myclabs/deep-copy": "^1.13.4",
                 "phar-io/manifest": "^2.0.4",
                 "phar-io/version": "^3.2.1",
-                "php": ">=7.3",
-                "phpunit/php-code-coverage": "^9.2.32",
-                "phpunit/php-file-iterator": "^3.0.6",
-                "phpunit/php-invoker": "^3.1.1",
-                "phpunit/php-text-template": "^2.0.4",
-                "phpunit/php-timer": "^5.0.3",
-                "sebastian/cli-parser": "^1.0.2",
-                "sebastian/code-unit": "^1.0.8",
-                "sebastian/comparator": "^4.0.10",
-                "sebastian/diff": "^4.0.6",
-                "sebastian/environment": "^5.1.5",
-                "sebastian/exporter": "^4.0.8",
-                "sebastian/global-state": "^5.0.8",
-                "sebastian/object-enumerator": "^4.0.4",
-                "sebastian/resource-operations": "^3.0.4",
-                "sebastian/type": "^3.2.1",
-                "sebastian/version": "^3.0.2"
-            },
-            "suggest": {
-                "ext-soap": "To be able to generate mocks based on WSDL files",
-                "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage"
+                "php": ">=8.3",
+                "phpunit/php-code-coverage": "^12.5.6",
+                "phpunit/php-file-iterator": "^6.0.1",
+                "phpunit/php-invoker": "^6.0.0",
+                "phpunit/php-text-template": "^5.0.0",
+                "phpunit/php-timer": "^8.0.0",
+                "sebastian/cli-parser": "^4.2.0",
+                "sebastian/comparator": "^7.1.6",
+                "sebastian/diff": "^7.0.0",
+                "sebastian/environment": "^8.1.0",
+                "sebastian/exporter": "^7.0.2",
+                "sebastian/global-state": "^8.0.2",
+                "sebastian/object-enumerator": "^7.0.0",
+                "sebastian/recursion-context": "^7.0.1",
+                "sebastian/type": "^6.0.3",
+                "sebastian/version": "^6.0.0",
+                "staabm/side-effects-detector": "^1.0.5"
             },
             "bin": [
                 "phpunit"
@@ -3300,7 +3746,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "9.6-dev"
+                    "dev-main": "12.5-dev"
                 }
             },
             "autoload": {
@@ -3332,7 +3778,7 @@
             "support": {
                 "issues": "https://github.com/sebastianbergmann/phpunit/issues",
                 "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
-                "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.35"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/12.5.23"
             },
             "funding": [
                 {
@@ -3340,7 +3786,7 @@
                     "type": "other"
                 }
             ],
-            "time": "2026-07-06T14:48:07+00:00"
+            "time": "2026-04-18T06:12:49+00:00"
         },
         {
             "name": "rregeer/phpunit-coverage-check",
@@ -3390,28 +3836,28 @@
         },
         {
             "name": "sebastian/cli-parser",
-            "version": "1.0.2",
+            "version": "4.2.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/cli-parser.git",
-                "reference": "2b56bea83a09de3ac06bb18b92f068e60cc6f50b"
+                "reference": "90f41072d220e5c40df6e8635f5dafba2d9d4d04"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/2b56bea83a09de3ac06bb18b92f068e60cc6f50b",
-                "reference": "2b56bea83a09de3ac06bb18b92f068e60cc6f50b",
+                "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/90f41072d220e5c40df6e8635f5dafba2d9d4d04",
+                "reference": "90f41072d220e5c40df6e8635f5dafba2d9d4d04",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "1.0-dev"
+                    "dev-main": "4.2-dev"
                 }
             },
             "autoload": {
@@ -3434,153 +3880,60 @@
             "homepage": "https://github.com/sebastianbergmann/cli-parser",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/cli-parser/issues",
-                "source": "https://github.com/sebastianbergmann/cli-parser/tree/1.0.2"
+                "security": "https://github.com/sebastianbergmann/cli-parser/security/policy",
+                "source": "https://github.com/sebastianbergmann/cli-parser/tree/4.2.0"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
-                }
-            ],
-            "time": "2024-03-02T06:27:43+00:00"
-        },
-        {
-            "name": "sebastian/code-unit",
-            "version": "1.0.8",
-            "source": {
-                "type": "git",
-                "url": "https://github.com/sebastianbergmann/code-unit.git",
-                "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120"
-            },
-            "dist": {
-                "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/code-unit/zipball/1fc9f64c0927627ef78ba436c9b17d967e68e120",
-                "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120",
-                "shasum": ""
-            },
-            "require": {
-                "php": ">=7.3"
-            },
-            "require-dev": {
-                "phpunit/phpunit": "^9.3"
-            },
-            "type": "library",
-            "extra": {
-                "branch-alias": {
-                    "dev-master": "1.0-dev"
-                }
-            },
-            "autoload": {
-                "classmap": [
-                    "src/"
-                ]
-            },
-            "notification-url": "https://packagist.org/downloads/",
-            "license": [
-                "BSD-3-Clause"
-            ],
-            "authors": [
-                {
-                    "name": "Sebastian Bergmann",
-                    "email": "sebastian@phpunit.de",
-                    "role": "lead"
-                }
-            ],
-            "description": "Collection of value objects that represent the PHP code units",
-            "homepage": "https://github.com/sebastianbergmann/code-unit",
-            "support": {
-                "issues": "https://github.com/sebastianbergmann/code-unit/issues",
-                "source": "https://github.com/sebastianbergmann/code-unit/tree/1.0.8"
-            },
-            "funding": [
+                },
                 {
-                    "url": "https://github.com/sebastianbergmann",
-                    "type": "github"
-                }
-            ],
-            "time": "2020-10-26T13:08:54+00:00"
-        },
-        {
-            "name": "sebastian/code-unit-reverse-lookup",
-            "version": "2.0.3",
-            "source": {
-                "type": "git",
-                "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
-                "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5"
-            },
-            "dist": {
-                "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
-                "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
-                "shasum": ""
-            },
-            "require": {
-                "php": ">=7.3"
-            },
-            "require-dev": {
-                "phpunit/phpunit": "^9.3"
-            },
-            "type": "library",
-            "extra": {
-                "branch-alias": {
-                    "dev-master": "2.0-dev"
-                }
-            },
-            "autoload": {
-                "classmap": [
-                    "src/"
-                ]
-            },
-            "notification-url": "https://packagist.org/downloads/",
-            "license": [
-                "BSD-3-Clause"
-            ],
-            "authors": [
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
                 {
-                    "name": "Sebastian Bergmann",
-                    "email": "sebastian@phpunit.de"
-                }
-            ],
-            "description": "Looks up which function or method a line of code belongs to",
-            "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
-            "support": {
-                "issues": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/issues",
-                "source": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/tree/2.0.3"
-            },
-            "funding": [
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
                 {
-                    "url": "https://github.com/sebastianbergmann",
-                    "type": "github"
+                    "url": "https://tidelift.com/funding/github/packagist/sebastian/cli-parser",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2020-09-28T05:30:19+00:00"
+            "time": "2025-09-14T09:36:45+00:00"
         },
         {
             "name": "sebastian/comparator",
-            "version": "4.0.10",
+            "version": "7.1.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/comparator.git",
-                "reference": "e4df00b9b3571187db2831ae9aada2c6efbd715d"
+                "reference": "c769009dee98f494e0edc3fd4f4087501688f11e"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/e4df00b9b3571187db2831ae9aada2c6efbd715d",
-                "reference": "e4df00b9b3571187db2831ae9aada2c6efbd715d",
+                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/c769009dee98f494e0edc3fd4f4087501688f11e",
+                "reference": "c769009dee98f494e0edc3fd4f4087501688f11e",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3",
-                "sebastian/diff": "^4.0",
-                "sebastian/exporter": "^4.0"
+                "ext-dom": "*",
+                "ext-mbstring": "*",
+                "php": ">=8.3",
+                "sebastian/diff": "^7.0",
+                "sebastian/exporter": "^7.0"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.2"
+            },
+            "suggest": {
+                "ext-bcmath": "For comparing BcMath\\Number objects"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "4.0-dev"
+                    "dev-main": "7.1-dev"
                 }
             },
             "autoload": {
@@ -3619,7 +3972,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/comparator/issues",
-                "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.10"
+                "security": "https://github.com/sebastianbergmann/comparator/security/policy",
+                "source": "https://github.com/sebastianbergmann/comparator/tree/7.1.6"
             },
             "funding": [
                 {
@@ -3639,33 +3993,33 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-01-24T09:22:56+00:00"
+            "time": "2026-04-14T08:23:15+00:00"
         },
         {
             "name": "sebastian/complexity",
-            "version": "2.0.3",
+            "version": "5.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/complexity.git",
-                "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a"
+                "reference": "bad4316aba5303d0221f43f8cee37eb58d384bbb"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/25f207c40d62b8b7aa32f5ab026c53561964053a",
-                "reference": "25f207c40d62b8b7aa32f5ab026c53561964053a",
+                "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/bad4316aba5303d0221f43f8cee37eb58d384bbb",
+                "reference": "bad4316aba5303d0221f43f8cee37eb58d384bbb",
                 "shasum": ""
             },
             "require": {
-                "nikic/php-parser": "^4.18 || ^5.0",
-                "php": ">=7.3"
+                "nikic/php-parser": "^5.0",
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "2.0-dev"
+                    "dev-main": "5.0-dev"
                 }
             },
             "autoload": {
@@ -3688,7 +4042,8 @@
             "homepage": "https://github.com/sebastianbergmann/complexity",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/complexity/issues",
-                "source": "https://github.com/sebastianbergmann/complexity/tree/2.0.3"
+                "security": "https://github.com/sebastianbergmann/complexity/security/policy",
+                "source": "https://github.com/sebastianbergmann/complexity/tree/5.0.0"
             },
             "funding": [
                 {
@@ -3696,33 +4051,33 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-12-22T06:19:30+00:00"
+            "time": "2025-02-07T04:55:25+00:00"
         },
         {
             "name": "sebastian/diff",
-            "version": "4.0.6",
+            "version": "7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/diff.git",
-                "reference": "ba01945089c3a293b01ba9badc29ad55b106b0bc"
+                "reference": "7ab1ea946c012266ca32390913653d844ecd085f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/ba01945089c3a293b01ba9badc29ad55b106b0bc",
-                "reference": "ba01945089c3a293b01ba9badc29ad55b106b0bc",
+                "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/7ab1ea946c012266ca32390913653d844ecd085f",
+                "reference": "7ab1ea946c012266ca32390913653d844ecd085f",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3",
-                "symfony/process": "^4.2 || ^5"
+                "phpunit/phpunit": "^12.0",
+                "symfony/process": "^7.2"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "4.0-dev"
+                    "dev-main": "7.0-dev"
                 }
             },
             "autoload": {
@@ -3754,7 +4109,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/diff/issues",
-                "source": "https://github.com/sebastianbergmann/diff/tree/4.0.6"
+                "security": "https://github.com/sebastianbergmann/diff/security/policy",
+                "source": "https://github.com/sebastianbergmann/diff/tree/7.0.0"
             },
             "funding": [
                 {
@@ -3762,27 +4118,27 @@
                     "type": "github"
                 }
             ],
-            "time": "2024-03-02T06:30:58+00:00"
+            "time": "2025-02-07T04:55:46+00:00"
         },
         {
             "name": "sebastian/environment",
-            "version": "5.1.5",
+            "version": "8.1.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/environment.git",
-                "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed"
+                "reference": "b121608b28a13f721e76ffbbd386d08eff58f3f6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
-                "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+                "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/b121608b28a13f721e76ffbbd386d08eff58f3f6",
+                "reference": "b121608b28a13f721e76ffbbd386d08eff58f3f6",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "suggest": {
                 "ext-posix": "*"
@@ -3790,7 +4146,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "5.1-dev"
+                    "dev-main": "8.1-dev"
                 }
             },
             "autoload": {
@@ -3809,7 +4165,7 @@
                 }
             ],
             "description": "Provides functionality to handle HHVM/PHP environments",
-            "homepage": "http://www.github.com/sebastianbergmann/environment",
+            "homepage": "https://github.com/sebastianbergmann/environment",
             "keywords": [
                 "Xdebug",
                 "environment",
@@ -3817,42 +4173,55 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/environment/issues",
-                "source": "https://github.com/sebastianbergmann/environment/tree/5.1.5"
+                "security": "https://github.com/sebastianbergmann/environment/security/policy",
+                "source": "https://github.com/sebastianbergmann/environment/tree/8.1.0"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
+                },
+                {
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/sebastian/environment",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2023-02-03T06:03:51+00:00"
+            "time": "2026-04-15T12:13:01+00:00"
         },
         {
             "name": "sebastian/exporter",
-            "version": "4.0.8",
+            "version": "7.0.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/exporter.git",
-                "reference": "14c6ba52f95a36c3d27c835d65efc7123c446e8c"
+                "reference": "016951ae10980765e4e7aee491eb288c64e505b7"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/14c6ba52f95a36c3d27c835d65efc7123c446e8c",
-                "reference": "14c6ba52f95a36c3d27c835d65efc7123c446e8c",
+                "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/016951ae10980765e4e7aee491eb288c64e505b7",
+                "reference": "016951ae10980765e4e7aee491eb288c64e505b7",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3",
-                "sebastian/recursion-context": "^4.0"
+                "ext-mbstring": "*",
+                "php": ">=8.3",
+                "sebastian/recursion-context": "^7.0"
             },
             "require-dev": {
-                "ext-mbstring": "*",
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "4.0-dev"
+                    "dev-main": "7.0-dev"
                 }
             },
             "autoload": {
@@ -3894,7 +4263,8 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/exporter/issues",
-                "source": "https://github.com/sebastianbergmann/exporter/tree/4.0.8"
+                "security": "https://github.com/sebastianbergmann/exporter/security/policy",
+                "source": "https://github.com/sebastianbergmann/exporter/tree/7.0.2"
             },
             "funding": [
                 {
@@ -3914,38 +4284,35 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2025-09-24T06:03:27+00:00"
+            "time": "2025-09-24T06:16:11+00:00"
         },
         {
             "name": "sebastian/global-state",
-            "version": "5.0.8",
+            "version": "8.0.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/global-state.git",
-                "reference": "b6781316bdcd28260904e7cc18ec983d0d2ef4f6"
+                "reference": "ef1377171613d09edd25b7816f05be8313f9115d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/b6781316bdcd28260904e7cc18ec983d0d2ef4f6",
-                "reference": "b6781316bdcd28260904e7cc18ec983d0d2ef4f6",
+                "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/ef1377171613d09edd25b7816f05be8313f9115d",
+                "reference": "ef1377171613d09edd25b7816f05be8313f9115d",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3",
-                "sebastian/object-reflector": "^2.0",
-                "sebastian/recursion-context": "^4.0"
+                "php": ">=8.3",
+                "sebastian/object-reflector": "^5.0",
+                "sebastian/recursion-context": "^7.0"
             },
             "require-dev": {
                 "ext-dom": "*",
-                "phpunit/phpunit": "^9.3"
-            },
-            "suggest": {
-                "ext-uopz": "*"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "5.0-dev"
+                    "dev-main": "8.0-dev"
                 }
             },
             "autoload": {
@@ -3964,13 +4331,14 @@
                 }
             ],
             "description": "Snapshotting of global state",
-            "homepage": "http://www.github.com/sebastianbergmann/global-state",
+            "homepage": "https://www.github.com/sebastianbergmann/global-state",
             "keywords": [
                 "global state"
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/global-state/issues",
-                "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.8"
+                "security": "https://github.com/sebastianbergmann/global-state/security/policy",
+                "source": "https://github.com/sebastianbergmann/global-state/tree/8.0.2"
             },
             "funding": [
                 {
@@ -3990,33 +4358,33 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2025-08-10T07:10:35+00:00"
+            "time": "2025-08-29T11:29:25+00:00"
         },
         {
             "name": "sebastian/lines-of-code",
-            "version": "1.0.4",
+            "version": "4.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/lines-of-code.git",
-                "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5"
+                "reference": "97ffee3bcfb5805568d6af7f0f893678fc076d2f"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/e1e4a170560925c26d424b6a03aed157e7dcc5c5",
-                "reference": "e1e4a170560925c26d424b6a03aed157e7dcc5c5",
+                "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/97ffee3bcfb5805568d6af7f0f893678fc076d2f",
+                "reference": "97ffee3bcfb5805568d6af7f0f893678fc076d2f",
                 "shasum": ""
             },
             "require": {
-                "nikic/php-parser": "^4.18 || ^5.0",
-                "php": ">=7.3"
+                "nikic/php-parser": "^5.0",
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "1.0-dev"
+                    "dev-main": "4.0-dev"
                 }
             },
             "autoload": {
@@ -4039,7 +4407,8 @@
             "homepage": "https://github.com/sebastianbergmann/lines-of-code",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/lines-of-code/issues",
-                "source": "https://github.com/sebastianbergmann/lines-of-code/tree/1.0.4"
+                "security": "https://github.com/sebastianbergmann/lines-of-code/security/policy",
+                "source": "https://github.com/sebastianbergmann/lines-of-code/tree/4.0.0"
             },
             "funding": [
                 {
@@ -4047,34 +4416,34 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-12-22T06:20:34+00:00"
+            "time": "2025-02-07T04:57:28+00:00"
         },
         {
             "name": "sebastian/object-enumerator",
-            "version": "4.0.4",
+            "version": "7.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/object-enumerator.git",
-                "reference": "5c9eeac41b290a3712d88851518825ad78f45c71"
+                "reference": "1effe8e9b8e068e9ae228e542d5d11b5d16db894"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/5c9eeac41b290a3712d88851518825ad78f45c71",
-                "reference": "5c9eeac41b290a3712d88851518825ad78f45c71",
+                "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/1effe8e9b8e068e9ae228e542d5d11b5d16db894",
+                "reference": "1effe8e9b8e068e9ae228e542d5d11b5d16db894",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3",
-                "sebastian/object-reflector": "^2.0",
-                "sebastian/recursion-context": "^4.0"
+                "php": ">=8.3",
+                "sebastian/object-reflector": "^5.0",
+                "sebastian/recursion-context": "^7.0"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "4.0-dev"
+                    "dev-main": "7.0-dev"
                 }
             },
             "autoload": {
@@ -4096,7 +4465,8 @@
             "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/object-enumerator/issues",
-                "source": "https://github.com/sebastianbergmann/object-enumerator/tree/4.0.4"
+                "security": "https://github.com/sebastianbergmann/object-enumerator/security/policy",
+                "source": "https://github.com/sebastianbergmann/object-enumerator/tree/7.0.0"
             },
             "funding": [
                 {
@@ -4104,32 +4474,32 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-10-26T13:12:34+00:00"
+            "time": "2025-02-07T04:57:48+00:00"
         },
         {
             "name": "sebastian/object-reflector",
-            "version": "2.0.4",
+            "version": "5.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/object-reflector.git",
-                "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7"
+                "reference": "4bfa827c969c98be1e527abd576533293c634f6a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
-                "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
+                "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/4bfa827c969c98be1e527abd576533293c634f6a",
+                "reference": "4bfa827c969c98be1e527abd576533293c634f6a",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "2.0-dev"
+                    "dev-main": "5.0-dev"
                 }
             },
             "autoload": {
@@ -4151,7 +4521,8 @@
             "homepage": "https://github.com/sebastianbergmann/object-reflector/",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/object-reflector/issues",
-                "source": "https://github.com/sebastianbergmann/object-reflector/tree/2.0.4"
+                "security": "https://github.com/sebastianbergmann/object-reflector/security/policy",
+                "source": "https://github.com/sebastianbergmann/object-reflector/tree/5.0.0"
             },
             "funding": [
                 {
@@ -4159,32 +4530,32 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-10-26T13:14:26+00:00"
+            "time": "2025-02-07T04:58:17+00:00"
         },
         {
             "name": "sebastian/recursion-context",
-            "version": "4.0.6",
+            "version": "7.0.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
-                "reference": "539c6691e0623af6dc6f9c20384c120f963465a0"
+                "reference": "0b01998a7d5b1f122911a66bebcb8d46f0c82d8c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/539c6691e0623af6dc6f9c20384c120f963465a0",
-                "reference": "539c6691e0623af6dc6f9c20384c120f963465a0",
+                "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/0b01998a7d5b1f122911a66bebcb8d46f0c82d8c",
+                "reference": "0b01998a7d5b1f122911a66bebcb8d46f0c82d8c",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "4.0-dev"
+                    "dev-main": "7.0-dev"
                 }
             },
             "autoload": {
@@ -4214,7 +4585,8 @@
             "homepage": "https://github.com/sebastianbergmann/recursion-context",
             "support": {
                 "issues": "https://github.com/sebastianbergmann/recursion-context/issues",
-                "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.6"
+                "security": "https://github.com/sebastianbergmann/recursion-context/security/policy",
+                "source": "https://github.com/sebastianbergmann/recursion-context/tree/7.0.1"
             },
             "funding": [
                 {
@@ -4234,32 +4606,32 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2025-08-10T06:57:39+00:00"
+            "time": "2025-08-13T04:44:59+00:00"
         },
         {
-            "name": "sebastian/resource-operations",
-            "version": "3.0.4",
+            "name": "sebastian/type",
+            "version": "6.0.3",
             "source": {
                 "type": "git",
-                "url": "https://github.com/sebastianbergmann/resource-operations.git",
-                "reference": "05d5692a7993ecccd56a03e40cd7e5b09b1d404e"
+                "url": "https://github.com/sebastianbergmann/type.git",
+                "reference": "e549163b9760b8f71f191651d22acf32d56d6d4d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/05d5692a7993ecccd56a03e40cd7e5b09b1d404e",
-                "reference": "05d5692a7993ecccd56a03e40cd7e5b09b1d404e",
+                "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/e549163b9760b8f71f191651d22acf32d56d6d4d",
+                "reference": "e549163b9760b8f71f191651d22acf32d56d6d4d",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.0"
+                "phpunit/phpunit": "^12.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "3.0-dev"
+                    "dev-main": "6.0-dev"
                 }
             },
             "autoload": {
@@ -4274,46 +4646,58 @@
             "authors": [
                 {
                     "name": "Sebastian Bergmann",
-                    "email": "sebastian@phpunit.de"
+                    "email": "sebastian@phpunit.de",
+                    "role": "lead"
                 }
             ],
-            "description": "Provides a list of PHP built-in functions that operate on resources",
-            "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
+            "description": "Collection of value objects that represent the types of the PHP type system",
+            "homepage": "https://github.com/sebastianbergmann/type",
             "support": {
-                "source": "https://github.com/sebastianbergmann/resource-operations/tree/3.0.4"
+                "issues": "https://github.com/sebastianbergmann/type/issues",
+                "security": "https://github.com/sebastianbergmann/type/security/policy",
+                "source": "https://github.com/sebastianbergmann/type/tree/6.0.3"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
+                },
+                {
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/sebastian/type",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2024-03-14T16:00:52+00:00"
+            "time": "2025-08-09T06:57:12+00:00"
         },
         {
-            "name": "sebastian/type",
-            "version": "3.2.1",
+            "name": "sebastian/version",
+            "version": "6.0.0",
             "source": {
                 "type": "git",
-                "url": "https://github.com/sebastianbergmann/type.git",
-                "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7"
+                "url": "https://github.com/sebastianbergmann/version.git",
+                "reference": "3e6ccf7657d4f0a59200564b08cead899313b53c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
-                "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
+                "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/3e6ccf7657d4f0a59200564b08cead899313b53c",
+                "reference": "3e6ccf7657d4f0a59200564b08cead899313b53c",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
-            },
-            "require-dev": {
-                "phpunit/phpunit": "^9.5"
+                "php": ">=8.3"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "3.2-dev"
+                    "dev-main": "6.0-dev"
                 }
             },
             "autoload": {
@@ -4332,11 +4716,12 @@
                     "role": "lead"
                 }
             ],
-            "description": "Collection of value objects that represent the types of the PHP type system",
-            "homepage": "https://github.com/sebastianbergmann/type",
+            "description": "Library that helps with managing the version number of Git-hosted PHP projects",
+            "homepage": "https://github.com/sebastianbergmann/version",
             "support": {
-                "issues": "https://github.com/sebastianbergmann/type/issues",
-                "source": "https://github.com/sebastianbergmann/type/tree/3.2.1"
+                "issues": "https://github.com/sebastianbergmann/version/issues",
+                "security": "https://github.com/sebastianbergmann/version/security/policy",
+                "source": "https://github.com/sebastianbergmann/version/tree/6.0.0"
             },
             "funding": [
                 {
@@ -4344,60 +4729,59 @@
                     "type": "github"
                 }
             ],
-            "time": "2023-02-03T06:13:03+00:00"
+            "time": "2025-02-07T05:00:38+00:00"
         },
         {
-            "name": "sebastian/version",
-            "version": "3.0.2",
+            "name": "staabm/side-effects-detector",
+            "version": "1.0.5",
             "source": {
                 "type": "git",
-                "url": "https://github.com/sebastianbergmann/version.git",
-                "reference": "c6c1022351a901512170118436c764e473f6de8c"
+                "url": "https://github.com/staabm/side-effects-detector.git",
+                "reference": "d8334211a140ce329c13726d4a715adbddd0a163"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c6c1022351a901512170118436c764e473f6de8c",
-                "reference": "c6c1022351a901512170118436c764e473f6de8c",
+                "url": "https://api.github.com/repos/staabm/side-effects-detector/zipball/d8334211a140ce329c13726d4a715adbddd0a163",
+                "reference": "d8334211a140ce329c13726d4a715adbddd0a163",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "ext-tokenizer": "*",
+                "php": "^7.4 || ^8.0"
             },
-            "type": "library",
-            "extra": {
-                "branch-alias": {
-                    "dev-master": "3.0-dev"
-                }
+            "require-dev": {
+                "phpstan/extension-installer": "^1.4.3",
+                "phpstan/phpstan": "^1.12.6",
+                "phpunit/phpunit": "^9.6.21",
+                "symfony/var-dumper": "^5.4.43",
+                "tomasvotruba/type-coverage": "1.0.0",
+                "tomasvotruba/unused-public": "1.0.0"
             },
+            "type": "library",
             "autoload": {
                 "classmap": [
-                    "src/"
+                    "lib/"
                 ]
             },
             "notification-url": "https://packagist.org/downloads/",
             "license": [
-                "BSD-3-Clause"
+                "MIT"
             ],
-            "authors": [
-                {
-                    "name": "Sebastian Bergmann",
-                    "email": "sebastian@phpunit.de",
-                    "role": "lead"
-                }
+            "description": "A static analysis tool to detect side effects in PHP code",
+            "keywords": [
+                "static analysis"
             ],
-            "description": "Library that helps with managing the version number of Git-hosted PHP projects",
-            "homepage": "https://github.com/sebastianbergmann/version",
             "support": {
-                "issues": "https://github.com/sebastianbergmann/version/issues",
-                "source": "https://github.com/sebastianbergmann/version/tree/3.0.2"
+                "issues": "https://github.com/staabm/side-effects-detector/issues",
+                "source": "https://github.com/staabm/side-effects-detector/tree/1.0.5"
             },
             "funding": [
                 {
-                    "url": "https://github.com/sebastianbergmann",
+                    "url": "https://github.com/staabm",
                     "type": "github"
                 }
             ],
-            "time": "2020-09-28T06:39:44+00:00"
+            "time": "2024-10-20T05:08:20+00:00"
         },
         {
             "name": "swoole/ide-helper",
@@ -4432,24 +4816,519 @@
             "time": "2024-06-17T05:45:20+00:00"
         },
         {
-            "name": "theseer/tokenizer",
-            "version": "1.3.1",
+            "name": "symfony/console",
+            "version": "v8.0.8",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/console.git",
+                "reference": "5b66d385dc58f69652e56f78a4184615e3f2b7f7"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/console/zipball/5b66d385dc58f69652e56f78a4184615e3f2b7f7",
+                "reference": "5b66d385dc58f69652e56f78a4184615e3f2b7f7",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4",
+                "symfony/polyfill-mbstring": "^1.0",
+                "symfony/service-contracts": "^2.5|^3",
+                "symfony/string": "^7.4|^8.0"
+            },
+            "provide": {
+                "psr/log-implementation": "1.0|2.0|3.0"
+            },
+            "require-dev": {
+                "psr/log": "^1|^2|^3",
+                "symfony/config": "^7.4|^8.0",
+                "symfony/dependency-injection": "^7.4|^8.0",
+                "symfony/event-dispatcher": "^7.4|^8.0",
+                "symfony/http-foundation": "^7.4|^8.0",
+                "symfony/http-kernel": "^7.4|^8.0",
+                "symfony/lock": "^7.4|^8.0",
+                "symfony/messenger": "^7.4|^8.0",
+                "symfony/process": "^7.4|^8.0",
+                "symfony/stopwatch": "^7.4|^8.0",
+                "symfony/var-dumper": "^7.4|^8.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Symfony\\Component\\Console\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Eases the creation of beautiful and testable command line interfaces",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "cli",
+                "command-line",
+                "console",
+                "terminal"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/console/tree/v8.0.8"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-30T15:14:47+00:00"
+        },
+        {
+            "name": "symfony/polyfill-ctype",
+            "version": "v1.37.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-ctype.git",
+                "reference": "141046a8f9477948ff284fa65be2095baafb94f2"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/141046a8f9477948ff284fa65be2095baafb94f2",
+                "reference": "141046a8f9477948ff284fa65be2095baafb94f2",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.2"
+            },
+            "provide": {
+                "ext-ctype": "*"
+            },
+            "suggest": {
+                "ext-ctype": "For best performance"
+            },
+            "type": "library",
+            "extra": {
+                "thanks": {
+                    "url": "https://github.com/symfony/polyfill",
+                    "name": "symfony/polyfill"
+                }
+            },
+            "autoload": {
+                "files": [
+                    "bootstrap.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Polyfill\\Ctype\\": ""
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Gert de Pagter",
+                    "email": "BackEndTea@gmail.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Symfony polyfill for ctype functions",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "compatibility",
+                "ctype",
+                "polyfill",
+                "portable"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/polyfill-ctype/tree/v1.37.0"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-04-10T16:19:22+00:00"
+        },
+        {
+            "name": "symfony/polyfill-intl-grapheme",
+            "version": "v1.37.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-intl-grapheme.git",
+                "reference": "4864388bfbd3001ce88e234fab652acd91fdc57e"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-intl-grapheme/zipball/4864388bfbd3001ce88e234fab652acd91fdc57e",
+                "reference": "4864388bfbd3001ce88e234fab652acd91fdc57e",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.2"
+            },
+            "suggest": {
+                "ext-intl": "For best performance"
+            },
+            "type": "library",
+            "extra": {
+                "thanks": {
+                    "url": "https://github.com/symfony/polyfill",
+                    "name": "symfony/polyfill"
+                }
+            },
+            "autoload": {
+                "files": [
+                    "bootstrap.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Polyfill\\Intl\\Grapheme\\": ""
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Nicolas Grekas",
+                    "email": "p@tchwork.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Symfony polyfill for intl's grapheme_* functions",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "compatibility",
+                "grapheme",
+                "intl",
+                "polyfill",
+                "portable",
+                "shim"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/polyfill-intl-grapheme/tree/v1.37.0"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-04-26T13:13:48+00:00"
+        },
+        {
+            "name": "symfony/polyfill-intl-normalizer",
+            "version": "v1.37.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-intl-normalizer.git",
+                "reference": "3833d7255cc303546435cb650316bff708a1c75c"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-intl-normalizer/zipball/3833d7255cc303546435cb650316bff708a1c75c",
+                "reference": "3833d7255cc303546435cb650316bff708a1c75c",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.2"
+            },
+            "suggest": {
+                "ext-intl": "For best performance"
+            },
+            "type": "library",
+            "extra": {
+                "thanks": {
+                    "url": "https://github.com/symfony/polyfill",
+                    "name": "symfony/polyfill"
+                }
+            },
+            "autoload": {
+                "files": [
+                    "bootstrap.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Polyfill\\Intl\\Normalizer\\": ""
+                },
+                "classmap": [
+                    "Resources/stubs"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Nicolas Grekas",
+                    "email": "p@tchwork.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Symfony polyfill for intl's Normalizer class and related functions",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "compatibility",
+                "intl",
+                "normalizer",
+                "polyfill",
+                "portable",
+                "shim"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/polyfill-intl-normalizer/tree/v1.37.0"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2024-09-09T11:45:10+00:00"
+        },
+        {
+            "name": "symfony/process",
+            "version": "v8.0.8",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/process.git",
+                "reference": "cb8939aff03470d1a9d1d1b66d08c6fa71b3bbdc"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/process/zipball/cb8939aff03470d1a9d1d1b66d08c6fa71b3bbdc",
+                "reference": "cb8939aff03470d1a9d1d1b66d08c6fa71b3bbdc",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Symfony\\Component\\Process\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Executes commands in sub-processes",
+            "homepage": "https://symfony.com",
+            "support": {
+                "source": "https://github.com/symfony/process/tree/v8.0.8"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-30T15:14:47+00:00"
+        },
+        {
+            "name": "symfony/string",
+            "version": "v8.0.8",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/string.git",
+                "reference": "ae9488f874d7603f9d2dfbf120203882b645d963"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/string/zipball/ae9488f874d7603f9d2dfbf120203882b645d963",
+                "reference": "ae9488f874d7603f9d2dfbf120203882b645d963",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4",
+                "symfony/polyfill-ctype": "^1.8",
+                "symfony/polyfill-intl-grapheme": "^1.33",
+                "symfony/polyfill-intl-normalizer": "^1.0",
+                "symfony/polyfill-mbstring": "^1.0"
+            },
+            "conflict": {
+                "symfony/translation-contracts": "<2.5"
+            },
+            "require-dev": {
+                "symfony/emoji": "^7.4|^8.0",
+                "symfony/http-client": "^7.4|^8.0",
+                "symfony/intl": "^7.4|^8.0",
+                "symfony/translation-contracts": "^2.5|^3.0",
+                "symfony/var-exporter": "^7.4|^8.0"
+            },
+            "type": "library",
+            "autoload": {
+                "files": [
+                    "Resources/functions.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Component\\String\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Nicolas Grekas",
+                    "email": "p@tchwork.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
+                }
+            ],
+            "description": "Provides an object-oriented API to strings and deals with bytes, UTF-8 code points and grapheme clusters in a unified way",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "grapheme",
+                "i18n",
+                "string",
+                "unicode",
+                "utf-8",
+                "utf8"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/string/tree/v8.0.8"
+            },
+            "funding": [
+                {
+                    "url": "https://symfony.com/sponsor",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/fabpot",
+                    "type": "github"
+                },
+                {
+                    "url": "https://github.com/nicolas-grekas",
+                    "type": "github"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/symfony/symfony",
+                    "type": "tidelift"
+                }
+            ],
+            "time": "2026-03-30T15:14:47+00:00"
+        },
+        {
+            "name": "theseer/tokenizer",
+            "version": "2.0.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/theseer/tokenizer.git",
-                "reference": "b7489ce515e168639d17feec34b8847c326b0b3c"
+                "reference": "7989e43bf381af0eac72e4f0ca5bcbfa81658be4"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/b7489ce515e168639d17feec34b8847c326b0b3c",
-                "reference": "b7489ce515e168639d17feec34b8847c326b0b3c",
+                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/7989e43bf381af0eac72e4f0ca5bcbfa81658be4",
+                "reference": "7989e43bf381af0eac72e4f0ca5bcbfa81658be4",
                 "shasum": ""
             },
             "require": {
                 "ext-dom": "*",
                 "ext-tokenizer": "*",
                 "ext-xmlwriter": "*",
-                "php": "^7.2 || ^8.0"
+                "php": "^8.1"
             },
             "type": "library",
             "autoload": {
@@ -4471,7 +5350,7 @@
             "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
             "support": {
                 "issues": "https://github.com/theseer/tokenizer/issues",
-                "source": "https://github.com/theseer/tokenizer/tree/1.3.1"
+                "source": "https://github.com/theseer/tokenizer/tree/2.0.1"
             },
             "funding": [
                 {
@@ -4479,7 +5358,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2025-11-17T20:03:58+00:00"
+            "time": "2025-12-08T11:19:18+00:00"
         },
         {
             "name": "utopia-php/cli",
@@ -4636,9 +5515,9 @@
         }
     ],
     "aliases": [],
-    "minimum-stability": "stable",
+    "minimum-stability": "dev",
     "stability-flags": {},
-    "prefer-stable": false,
+    "prefer-stable": true,
     "prefer-lowest": false,
     "platform": {
         "php": ">=8.5",
diff --git a/docker-compose.yml b/docker-compose.yml
index bbd6976e5f..10b3c036c0 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -4,6 +4,7 @@ services:
     image: databases-dev
     build:
       context: .
+      dockerfile: Dockerfile
       args:
         DEBUG: true
     networks:
@@ -19,29 +20,11 @@ services:
       - ./docker-compose.yml:/usr/src/code/docker-compose.yml
     environment:
       PHP_IDE_CONFIG: serverName=tests
-    depends_on:
-      postgres:
-        condition: service_healthy
-      postgres-mirror:
-        condition: service_healthy
-      mariadb:
-        condition: service_healthy
-      mariadb-mirror:
-        condition: service_healthy
-      mysql:
-        condition: service_healthy
-      mysql-mirror:
-        condition: service_healthy
-      redis:
-        condition: service_healthy
-      redis-mirror:
-        condition: service_healthy
-      mongo:
-        condition: service_healthy
 
   adminer:
     image: adminer
     container_name: utopia-adminer
+    profiles: [debug]
     restart: always
     ports:
       - "8700:8080"
@@ -55,6 +38,7 @@ services:
       args:
         POSTGRES_VERSION: 16
     container_name: utopia-postgres
+    profiles: [postgres]
     networks:
       - database
     ports:
@@ -77,6 +61,7 @@ services:
       args:
         POSTGRES_VERSION: 16
     container_name: utopia-postgres-mirror
+    profiles: [postgres-mirror]
     networks:
       - database
     ports:
@@ -95,6 +80,7 @@ services:
   mariadb:
     image: mariadb:10.11
     container_name: utopia-mariadb
+    profiles: [mariadb]
     command: mariadbd --max_allowed_packet=1G
     networks:
       - database
@@ -112,6 +98,7 @@ services:
   mariadb-mirror:
     image: mariadb:10.11
     container_name: utopia-mariadb-mirror
+    profiles: [mariadb-mirror]
     command: mariadbd --max_allowed_packet=1G
     networks:
       - database
@@ -129,6 +116,7 @@ services:
   mongo:
     image: mongo:8.0.14
     container_name: utopia-mongo
+    profiles: [mongo]
     entrypoint: ["/entrypoint.sh"]
     networks:
       - database
@@ -161,6 +149,7 @@ services:
   mongo-express:
     image: mongo-express
     container_name: mongo-express
+    profiles: [debug]
     depends_on:
       mongo:
         condition: service_healthy
@@ -176,6 +165,7 @@ services:
   mysql:
     image: mysql:8.0.43
     container_name: utopia-mysql
+    profiles: [mysql]
     networks:
       - database
     ports:
@@ -198,6 +188,7 @@ services:
   mysql-mirror:
     image: mysql:8.0.43
     container_name: utopia-mysql-mirror
+    profiles: [mysql-mirror]
     networks:
       - database
     ports:
@@ -220,6 +211,7 @@ services:
   redis:
     image: redis:8.2.1-alpine3.22
     container_name: utopia-redis
+    restart: always
     ports:
       - "8708:6379"
     networks:
@@ -234,6 +226,8 @@ services:
   redis-mirror:
     image: redis:8.2.1-alpine3.22
     container_name: utopia-redis-mirror
+    profiles: [redis-mirror]
+    restart: always
     ports:
       - "8709:6379"
     networks:
diff --git a/phpstan.neon b/phpstan.neon
new file mode 100644
index 0000000000..c8e20bf4af
--- /dev/null
+++ b/phpstan.neon
@@ -0,0 +1,16 @@
+includes:
+    - vendor/phpstan/phpstan-phpunit/extension.neon
+
+parameters:
+    level: max
+    paths:
+        - src
+        - tests
+    scanFiles:
+        - stubs/Swoole/Database/DetectsLostConnections.stub.php
+        - stubs/Swoole/Database/PDOProxy.stub.php
+        - stubs/Swoole/Database/PDOStatementProxy.stub.php
+    stubFiles:
+        - stubs/Swoole/Database/DetectsLostConnections.stub.php
+        - stubs/Swoole/Database/PDOProxy.stub.php
+        - stubs/Swoole/Database/PDOStatementProxy.stub.php
diff --git a/phpunit.xml b/phpunit.xml
index 2a0531cfd0..fa32485526 100755
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -1,13 +1,13 @@
-<phpunit 
-    backupGlobals="false"
-    backupStaticAttributes="false"
+<phpunit
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/12.0/phpunit.xsd"
     bootstrap="vendor/autoload.php"
     colors="true"
-    convertErrorsToExceptions="true"
-    convertNoticesToExceptions="true"
-    convertWarningsToExceptions="true"
     processIsolation="false"
     stopOnFailure="false"
+    requireCoverageMetadata="false"
+    displayDetailsOnPhpunitDeprecations="false"
+    displayDetailsOnPhpunitNotices="false"
 >
     <testsuites>
         <testsuite name="unit">
@@ -17,4 +17,4 @@
             <directory>./tests/e2e/Adapter</directory>
         </testsuite>
     </testsuites>
-</phpunit>
\ No newline at end of file
+</phpunit>
diff --git a/src/Database/Adapter.php b/src/Database/Adapter.php
index 4d2f0ee38f..0ba0b330ac 100644
--- a/src/Database/Adapter.php
+++ b/src/Database/Adapter.php
@@ -2,7 +2,10 @@
 
 namespace Utopia\Database;
 
+use DateTime;
 use Exception;
+use Throwable;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
 use Utopia\Database\Exception\Conflict as ConflictException;
@@ -12,11 +15,20 @@
 use Utopia\Database\Exception\Restricted as RestrictedException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Hook\Write;
+use Utopia\Database\Profiler\QueryProfiler;
 use Utopia\Database\Validator\Authorization;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Method;
 
-abstract class Adapter
+/**
+ * Abstract base class for all database adapters, providing shared state management and a contract for database operations.
+ */
+abstract class Adapter implements Feature\Attributes, Feature\Collections, Feature\Databases, Feature\Documents, Feature\Indexes, Feature\Transactions
 {
     protected string $database = '';
+
     protected string $hostname = '';
 
     protected string $namespace = '';
@@ -29,6 +41,11 @@ abstract class Adapter
 
     protected int $timeout = 0;
 
+    /**
+     * @var array<string, int>
+     */
+    protected array $timeouts = [];
+
     protected int $inTransaction = 0;
 
     protected bool $alterLocks = false;
@@ -41,11 +58,9 @@ abstract class Adapter
     protected array $debug = [];
 
     /**
-     * @var array<string, array<callable>>
+     * @var array<string, Transform>
      */
-    protected array $transformations = [
-        '*' => [],
-    ];
+    protected array $queryTransforms = [];
 
     /**
      * @var array<string, mixed>
@@ -53,13 +68,60 @@ abstract class Adapter
     protected array $metadata = [];
 
     /**
-     * @var Authorization
+     * @var list<Write>
      */
+    protected array $writeHooks = [];
+
+    protected ?QueryProfiler $profiler = null;
+
     protected Authorization $authorization;
 
+    /** @var array<string, true>|null */
+    protected ?array $capabilitySet = null;
+
+    /**
+     * Check if this adapter supports a given capability.
+     *
+     * @param  Capability  $feature  Capability enum case
+     */
+    public function supports(Capability $feature): bool
+    {
+        if ($this->capabilitySet === null) {
+            $this->capabilitySet = [];
+            foreach ($this->capabilities() as $cap) {
+                $this->capabilitySet[$cap->name] = true;
+            }
+        }
+        return isset($this->capabilitySet[$feature->name]);
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param  class-string<T>  $feature
+     *
+     * @phpstan-assert-if-true T $this
+     */
+    public function hasFeature(string $feature): bool
+    {
+        return $this instanceof $feature;
+    }
+
     /**
-     * @param Authorization $authorization
+     * Get the list of capabilities this adapter supports.
      *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return [
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+        ];
+    }
+
+    /**
      * @return $this
      */
     public function setAuthorization(Authorization $authorization): self
@@ -69,39 +131,51 @@ public function setAuthorization(Authorization $authorization): self
         return $this;
     }
 
+    /**
+     * Get the authorization instance used for permission checks.
+     *
+     * @return Authorization The current authorization instance.
+     */
     public function getAuthorization(): Authorization
     {
         return $this->authorization;
     }
-    /**
-     * @param string $key
-     * @param mixed $value
-     *
-     * @return $this
-     */
-    public function setDebug(string $key, mixed $value): static
+
+    public function setProfiler(?QueryProfiler $profiler): static
     {
-        $this->debug[$key] = $value;
+        $this->profiler = $profiler;
 
         return $this;
     }
 
+    public function getProfiler(): ?QueryProfiler
+    {
+        return $this->profiler;
+    }
+
     /**
-     * @return array<string, mixed>
+     * Set Database.
+     *
+     * Set database to use for current scope
+     *
+     *
+     * @throws DatabaseException
      */
-    public function getDebug(): array
+    public function setDatabase(string $name): bool
     {
-        return $this->debug;
+        $this->database = $this->filter($name);
+
+        return true;
     }
 
     /**
-     * @return static
+     * Get Database.
+     *
+     * Get Database from current scope
      */
-    public function resetDebug(): static
+    public function getDatabase(): string
     {
-        $this->debug = [];
-
-        return $this;
+        return $this->database;
     }
 
     /**
@@ -109,11 +183,10 @@ public function resetDebug(): static
      *
      * Set namespace to divide different scope of data sets
      *
-     * @param string $namespace
      *
      * @return $this
-     * @throws DatabaseException
      *
+     * @throws DatabaseException
      */
     public function setNamespace(string $namespace): static
     {
@@ -126,9 +199,6 @@ public function setNamespace(string $namespace): static
      * Get Namespace.
      *
      * Get namespace of current set scope
-     *
-     * @return string
-     *
      */
     public function getNamespace(): string
     {
@@ -138,7 +208,6 @@ public function getNamespace(): string
     /**
      * Set Hostname.
      *
-     * @param string $hostname
      * @return $this
      */
     public function setHostname(string $hostname): static
@@ -150,52 +219,16 @@ public function setHostname(string $hostname): static
 
     /**
      * Get Hostname.
-     *
-     * @return string
      */
     public function getHostname(): string
     {
         return $this->hostname;
     }
 
-    /**
-     * Set Database.
-     *
-     * Set database to use for current scope
-     *
-     * @param string $name
-     *
-     * @return bool
-     * @throws DatabaseException
-     */
-    public function setDatabase(string $name): bool
-    {
-        $this->database = $this->filter($name);
-
-        return true;
-    }
-
-    /**
-     * Get Database.
-     *
-     * Get Database from current scope
-     *
-     * @return string
-     *
-     */
-    public function getDatabase(): string
-    {
-        return $this->database;
-    }
-
     /**
      * Set Shared Tables.
      *
      * Set whether to share tables between tenants
-     *
-     * @param bool $sharedTables
-     *
-     * @return bool
      */
     public function setSharedTables(bool $sharedTables): bool
     {
@@ -208,8 +241,6 @@ public function setSharedTables(bool $sharedTables): bool
      * Get Share Tables.
      *
      * Get whether to share tables between tenants
-     *
-     * @return bool
      */
     public function getSharedTables(): bool
     {
@@ -220,10 +251,6 @@ public function getSharedTables(): bool
      * Set Tenant.
      *
      * Set tenant to use if tables are shared
-     *
-     * @param int|string|null $tenant
-     *
-     * @return bool
      */
     public function setTenant(int|string|null $tenant): bool
     {
@@ -235,12 +262,20 @@ public function setTenant(int|string|null $tenant): bool
     /**
      * Get Tenant.
      *
-     * Get tenant to use for shared tables
+     * Get tenant to use for shared tables.
      *
-     * @return int|string|null
+     * `_tenant` is an INT UNSIGNED column, so the engine reads "001" and "1"
+     * as the same tenant and returns both rows for either. Normalising every
+     * digit-only string mirrors that. Keeping them apart in PHP would be worse
+     * than the collapse: the scope comparison and the cache key would claim a
+     * distinction the rows do not have.
      */
     public function getTenant(): int|string|null
     {
+        if (\is_string($this->tenant) && \ctype_digit($this->tenant)) {
+            return (int) $this->tenant;
+        }
+
         return $this->tenant;
     }
 
@@ -248,10 +283,6 @@ public function getTenant(): int|string|null
      * Set Tenant Per Document.
      *
      * Set whether to use a different tenant for each document
-     *
-     * @param bool $tenantPerDocument
-     *
-     * @return bool
      */
     public function setTenantPerDocument(bool $tenantPerDocument): bool
     {
@@ -264,34 +295,57 @@ public function setTenantPerDocument(bool $tenantPerDocument): bool
      * Get Tenant Per Document.
      *
      * Get whether to use a different tenant for each document
-     *
-     * @return bool
      */
     public function getTenantPerDocument(): bool
     {
         return $this->tenantPerDocument;
     }
 
+    /**
+     * Set a debug key-value pair for diagnostic purposes.
+     *
+     * @param string $key The debug key.
+     * @param mixed $value The debug value.
+     * @return $this
+     */
+    public function setDebug(string $key, mixed $value): static
+    {
+        $this->debug[$key] = $value;
+
+        return $this;
+    }
+
+    /**
+     * Get all collected debug data.
+     *
+     * @return array<string, mixed>
+     */
+    public function getDebug(): array
+    {
+        return $this->debug;
+    }
+
+    /**
+     * Reset all debug data.
+     *
+     * @return $this
+     */
+    public function resetDebug(): static
+    {
+        $this->debug = [];
+
+        return $this;
+    }
+
     /**
      * Set metadata for query comments
      *
-     * @param string $key
-     * @param mixed $value
      * @return $this
      */
     public function setMetadata(string $key, mixed $value): static
     {
         $this->metadata[$key] = $value;
 
-        $output = '';
-        foreach ($this->metadata as $key => $value) {
-            $output .= "/* {$key}: {$value} */\n";
-        }
-
-        $this->before(Database::EVENT_ALL, 'metadata', function ($query) use ($output) {
-            return $output . $query;
-        });
-
         return $this;
     }
 
@@ -317,45 +371,177 @@ public function resetMetadata(): static
         return $this;
     }
 
+    protected function setTimeoutState(int $milliseconds, Event $event): void
+    {
+        $this->timeouts[$event->value] = $milliseconds;
+
+        if ($event === Event::All) {
+            $this->timeout = $milliseconds;
+        }
+    }
+
     /**
-     * Set a global timeout for database queries in milliseconds.
+     * Get the current query timeout value.
      *
-     * This function allows you to set a maximum execution time for all database
-     * queries executed using the library, or a specific event specified by the
-     * event parameter. Once this timeout is set, any database query that takes
-     * longer than the specified time will be automatically terminated by the library,
-     * and an appropriate error or exception will be raised to handle the timeout condition.
+     * @return int Timeout in milliseconds, or 0 if no timeout is set.
+     */
+    public function getTimeout(Event $event = Event::All): int
+    {
+        return $this->timeouts[$event->value]
+            ?? $this->timeouts[Event::All->value]
+            ?? $this->timeout;
+    }
+
+    protected function clearTimeoutState(Event $event): void
+    {
+        if ($event === Event::All) {
+            $this->timeouts = [];
+            $this->timeout = 0;
+
+            return;
+        }
+
+        unset($this->timeouts[$event->value]);
+    }
+
+    /**
+     * Enable or disable LOCK=SHARED during ALTER TABLE operations.
      *
-     * @param int $milliseconds The timeout value in milliseconds for database queries.
-     * @param string $event     The event the timeout should fire for
-     * @return void
+     * @param bool $enable True to enable alter locks.
+     * @return $this
+     */
+    public function enableAlterLocks(bool $enable): self
+    {
+        $this->alterLocks = $enable;
+
+        return $this;
+    }
+
+    public function getAlterLocks(): bool
+    {
+        return $this->alterLocks;
+    }
+
+    /**
+     * Set support for attributes
+     */
+    abstract public function setSupportForAttributes(bool $support): bool;
+
+    /**
+     * Register a write hook that intercepts document write operations.
      *
-     * @throws Exception The provided timeout value must be greater than or equal to 0.
+     * @param Write $hook The write hook to add.
+     * @return $this
      */
-    abstract public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void;
+    public function addWriteHook(Write $hook): static
+    {
+        $this->writeHooks[] = $hook;
+
+        return $this;
+    }
+
+    public function hasPermissionHook(): bool
+    {
+        foreach ($this->writeHooks as $hook) {
+            if ($hook instanceof Hook\Permissions) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function hasTenantHook(): bool
+    {
+        return $this->getTenantHook() !== null;
+    }
 
-    public function getTimeout(): int
+    public function getTenantHook(): ?Hook\Tenancy
     {
-        return $this->timeout;
+        foreach ($this->writeHooks as $hook) {
+            if ($hook instanceof Hook\Tenancy) {
+                return $hook;
+            }
+        }
+
+        return null;
     }
 
     /**
-     * Clears a global timeout for database queries.
+     * Remove a write hook by its class name.
      *
-     * @param string $event
-     * @return void
+     * @param string $class The fully qualified class name of the hook to remove.
+     * @return $this
+     */
+    public function removeWriteHook(string $class): static
+    {
+        $this->writeHooks = \array_values(\array_filter(
+            $this->writeHooks,
+            fn (Write $h) => ! ($h instanceof $class)
+        ));
+
+        return $this;
+    }
+
+    /**
+     * Get all registered write hooks.
+     *
+     * @return list<Write>
+     */
+    public function getWriteHooks(): array
+    {
+        return $this->writeHooks;
+    }
+
+    /**
+     * Register a named query transform hook that modifies queries before execution.
+     *
+     * @param string $name Unique name for the transform.
+     * @param Transform $transform The query transform hook to add.
+     * @return $this
+     */
+    public function addTransform(string $name, Transform $transform): static
+    {
+        $this->queryTransforms[$name] = $transform;
+
+        return $this;
+    }
+
+    /**
+     * Remove a query transform hook by name.
+     *
+     * @param string $name The name of the transform to remove.
+     * @return $this
+     */
+    public function removeTransform(string $name): static
+    {
+        unset($this->queryTransforms[$name]);
+
+        return $this;
+    }
+
+    /**
+     * Remove all registered query transform hooks.
+     *
+     * @return $this
      */
-    public function clearTimeout(string $event): void
+    public function resetTransforms(): static
     {
-        // Clear existing callback
-        $this->before($event, 'timeout');
+        $this->queryTransforms = [];
 
-        // Adapters that apply the timeout from this property on every statement
-        // (e.g. Postgres SET statement_timeout) would otherwise keep enforcing a
-        // cleared timeout on all subsequent queries.
-        $this->timeout = 0;
+        return $this;
     }
 
+    /**
+     * Ping Database
+     */
+    abstract public function ping(): bool;
+
+    /**
+     * Reconnect Database
+     */
+    abstract public function reconnect(): void;
+
     /**
      * Clears every timeout this adapter carries, for any event.
      *
@@ -367,11 +553,9 @@ public function clearTimeout(string $event): void
      */
     public function clearTimeouts(): void
     {
-        foreach (\array_keys($this->transformations) as $event) {
-            $this->clearTimeout($event);
-        }
-
-        $this->timeout = 0;
+        // Event::All empties the whole map rather than unsetting one entry, so
+        // this needs no knowledge of which events a previous holder set.
+        $this->clearTimeoutState(Event::All);
     }
 
     /**
@@ -379,7 +563,6 @@ public function clearTimeouts(): void
      *
      * If a transaction is already active, this will only increment the transaction count and return true.
      *
-     * @return bool
      * @throws DatabaseException
      */
     abstract public function startTransaction(): bool;
@@ -391,7 +574,6 @@ abstract public function startTransaction(): bool;
      * If there is more than one active transaction, this decrement the transaction count and return true.
      * If the transaction count is 1, it will be commited, the transaction count will be reset to 0, and return true.
      *
-     * @return bool
      * @throws DatabaseException
      */
     abstract public function commitTransaction(): bool;
@@ -402,15 +584,12 @@ abstract public function commitTransaction(): bool;
      * If no transaction is active, this will be a no-op and will return false.
      * If 1 or more transactions are active, this will roll back all transactions, reset the count to 0, and return true.
      *
-     * @return bool
      * @throws DatabaseException
      */
     abstract public function rollbackTransaction(): bool;
 
     /**
      * Check if a transaction is active.
-     *
-     * @return bool
      */
     public function inTransaction(): bool
     {
@@ -440,9 +619,11 @@ public function skipDuplicates(callable $callback): mixed
 
     /**
      * @template T
-     * @param callable(): T $callback
+     *
+     * @param  callable(): T  $callback
      * @return T
-     * @throws \Throwable
+     *
+     * @throws Throwable
      */
     public function withTransaction(callable $callback): mixed
     {
@@ -454,15 +635,13 @@ public function withTransaction(callable $callback): mixed
                 $this->startTransaction();
                 $result = $callback();
                 $this->commitTransaction();
+
                 return $result;
-            } catch (\Throwable $action) {
+            } catch (Throwable $action) {
                 $rollback = null;
                 try {
                     $this->rollbackTransaction();
-                } catch (\Throwable $rollbackError) {
-                    // Not every adapter resets the depth counter when its
-                    // rollback throws (e.g. Redis), so reset it here to avoid
-                    // leaking transaction state onto the reused connection.
+                } catch (Throwable $rollbackError) {
                     $rollback = $rollbackError;
                     $this->inTransaction = 0;
                 }
@@ -481,6 +660,7 @@ public function withTransaction(callable $callback): mixed
 
                 if ($attempts < $retries) {
                     \usleep($sleep * ($attempts + 1));
+
                     continue;
                 }
 
@@ -492,79 +672,18 @@ public function withTransaction(callable $callback): mixed
     }
 
     /**
-     * Apply a transformation to a query before an event occurs
+     * Create Database
+     */
+    abstract public function create(string $name): bool;
+
+    /**
+     * Check if database exists
+     * Optionally check if collection exists in database
      *
-     * @param string $event
-     * @param string $name
-     * @param ?callable $callback
-     * @return static
+     * @param  string  $database  database name
+     * @param  string|null  $collection  (optional) collection name
      */
-    public function before(string $event, string $name = '', ?callable $callback = null): static
-    {
-        if (!isset($this->transformations[$event])) {
-            $this->transformations[$event] = [];
-        }
-
-        if (\is_null($callback)) {
-            unset($this->transformations[$event][$name]);
-        } else {
-            $this->transformations[$event][$name] = $callback;
-        }
-
-        return $this;
-    }
-
-    protected function trigger(string $event, mixed $query): mixed
-    {
-        foreach ($this->transformations[Database::EVENT_ALL] as $callback) {
-            $query = $callback($query);
-        }
-        foreach (($this->transformations[$event] ?? []) as $callback) {
-            $query = $callback($query);
-        }
-
-        return $query;
-    }
-
-    /**
-     * Quote a string
-     *
-     * @param string $string
-     * @return string
-     */
-    abstract protected function quote(string $string): string;
-
-    /**
-     * Ping Database
-     *
-     * @return bool
-     */
-    abstract public function ping(): bool;
-
-    /**
-     * Reconnect Database
-     */
-    abstract public function reconnect(): void;
-
-    /**
-     * Create Database
-     *
-     * @param string $name
-     *
-     * @return bool
-     */
-    abstract public function create(string $name): bool;
-
-    /**
-     * Check if database exists
-     * Optionally check if collection exists in database
-     *
-     * @param string $database database name
-     * @param string|null $collection (optional) collection name
-     *
-     * @return bool
-     */
-    abstract public function exists(string $database, ?string $collection = null): bool;
+    abstract public function exists(string $database, ?string $collection = null): bool;
 
     /**
      * List Databases
@@ -575,61 +694,40 @@ abstract public function list(): array;
 
     /**
      * Delete Database
-     *
-     * @param string $name
-     *
-     * @return bool
      */
     abstract public function delete(string $name): bool;
 
     /**
      * Create Collection
      *
-     * @param string $name
-     * @param array<Document> $attributes (optional)
-     * @param array<Document> $indexes (optional)
-     * @return bool
+     * @param  array<Attribute>  $attributes  (optional)
+     * @param  array<Index>  $indexes  (optional)
      */
     abstract public function createCollection(string $name, array $attributes = [], array $indexes = []): bool;
 
     /**
      * Delete Collection
-     *
-     * @param string $id
-     *
-     * @return bool
      */
     abstract public function deleteCollection(string $id): bool;
 
     /**
      * Analyze a collection updating its metadata on the database engine
-     *
-     * @param string $collection
-     * @return bool
      */
     abstract public function analyzeCollection(string $collection): bool;
 
     /**
      * Create Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @return bool
      * @throws TimeoutException
      * @throws DuplicateException
      */
-    abstract public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool;
+    abstract public function createAttribute(string $collection, Attribute $attribute): bool;
 
     /**
      * Create Attributes
      *
-     * @param string $collection
-     * @param array<array<string, mixed>> $attributes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     *
      * @throws TimeoutException
      * @throws DuplicateException
      */
@@ -637,145 +735,44 @@ abstract public function createAttributes(string $collection, array $attributes)
 
     /**
      * Update Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $newKey
-     * @param bool $required
-     *
-     * @return bool
      */
-    abstract public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool;
+    abstract public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool;
 
     /**
      * Delete Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
      */
     abstract public function deleteAttribute(string $collection, string $id): bool;
 
     /**
      * Rename Attribute
-     *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
      */
     abstract public function renameAttribute(string $collection, string $old, string $new): bool;
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $id
-     * @param string $twoWayKey
-     * @return bool
-     */
-    abstract public function createRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay = false, string $id = '', string $twoWayKey = ''): bool;
-
-    /**
-     * Update Relationship
-     *
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @param string|null $newKey
-     * @param string|null $newTwoWayKey
-     * @return bool
-     */
-    abstract public function updateRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side, ?string $newKey = null, ?string $newTwoWayKey = null): bool;
-
-    /**
-     * Delete Relationship
-     *
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @return bool
+     * @param  array<string, string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
      */
-    abstract public function deleteRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side): bool;
-
-    /**
-     * Rename Index
-     *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
-     */
-    abstract public function renameIndex(string $collection, string $old, string $new): bool;
-
-    /**
-     * Create Index
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param array<string,string> $indexAttributeTypes
-     * @param array<string, mixed> $collation
-     * @param int $ttl
-     *
-     * @return bool
-     */
-    abstract public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool;
+    abstract public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool;
 
     /**
      * Delete Index
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
      */
     abstract public function deleteIndex(string $collection, string $id): bool;
 
     /**
-     * Get Document
-     *
-     * @param Document $collection
-     * @param string $id
-     * @param array<Query> $queries
-     * @param bool $forUpdate
-     * @return Document
+     * Rename Index
      */
-    abstract public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document;
+    abstract public function renameIndex(string $collection, string $old, string $new): bool;
 
     /**
      * Create Document
-     *
-     * @param Document $collection
-     * @param Document $document
-     *
-     * @return Document
      */
     abstract public function createDocument(Document $collection, Document $document): Document;
 
     /**
      * Create Documents in batches
      *
-     * @param Document $collection
-     * @param array<Document> $documents
-     *
+     * @param  array<Document>  $documents
      * @return array<Document>
      *
      * @throws DatabaseException
@@ -783,14 +780,14 @@ abstract public function createDocument(Document $collection, Document $document
     abstract public function createDocuments(Document $collection, array $documents): array;
 
     /**
-     * Update Document
-     *
-     * @param Document $collection
-     * @param string $id
-     * @param Document $document
-     * @param bool $skipPermissions
+     * Get Document
      *
-     * @return Document
+     * @param  array<Query>  $queries
+     */
+    abstract public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document;
+
+    /**
+     * Update Document
      */
     abstract public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document;
 
@@ -799,57 +796,37 @@ abstract public function updateDocument(Document $collection, string $id, Docume
      *
      * Updates all documents which match the given query.
      *
-     * @param Document $collection
-     * @param Document $updates
-     * @param array<Document> $documents
-     *
-     * @return int
+     * @param  array<Document>  $documents
      *
      * @throws DatabaseException
      */
     abstract public function updateDocuments(Document $collection, Document $updates, array $documents): int;
 
     /**
-     * Create documents if they do not exist, otherwise update them.
-     *
-     * If attribute is not empty, only the specified attribute will be increased, by the new value in each document.
+     * Increase or decrease attribute value
      *
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Change> $changes
-     * @return array<Document>
+     * @throws Exception
      */
-    abstract public function upsertDocuments(
-        Document $collection,
+    abstract public function increaseDocumentAttribute(
+        string $collection,
+        string $id,
         string $attribute,
-        array $changes
-    ): array;
-
-    /**
-     * @param string $collection
-     * @param array<Document> $documents
-     * @return array<Document>
-     */
-    abstract public function getSequences(string $collection, array $documents): array;
+        int|float|string $value,
+        string $updatedAt,
+        int|float|string|null $min = null,
+        int|float|string|null $max = null
+    ): bool;
 
     /**
      * Delete Document
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
      */
     abstract public function deleteDocument(string $collection, string $id): bool;
 
     /**
      * Delete Documents
      *
-     * @param string $collection
-     * @param array<string> $sequences
-     * @param array<string> $permissionIds
-     *
-     * @return int
+     * @param  array<string>  $sequences
+     * @param  array<string>  $permissionIds
      */
     abstract public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int;
 
@@ -858,71 +835,41 @@ abstract public function deleteDocuments(string $collection, array $sequences, a
      *
      * Find data sets using chosen queries
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $limit
-     * @param int|null $offset
-     * @param array<string> $orderAttributes
-     * @param array<string> $orderTypes
-     * @param array<string, mixed> $cursor
-     * @param string $cursorDirection
-     * @param string $forPermission
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<\Utopia\Query\OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
      * @return array<Document>
      */
-    abstract public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array;
-
-    /**
-     * Sum an attribute
-     *
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @param int|null $max
-     *
-     * @return int|float
-     */
-    abstract public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int;
+    abstract public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array;
 
     /**
      * Count Documents
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $max
-     *
-     * @return int
+     * @param  array<Query>  $queries
      */
     abstract public function count(Document $collection, array $queries = [], ?int $max = null): int;
 
     /**
-     * Get Collection Size of the raw data
+     * Sum an attribute
      *
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
+     * @param  array<Query>  $queries
      */
-    abstract public function getSizeOfCollection(string $collection): int;
+    abstract public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int;
 
     /**
-     * Get Collection Size on the disk
-     *
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
+     * @param  array<Document>  $documents
+     * @return array<Document>
      */
-    abstract public function getSizeOfCollectionOnDisk(string $collection): int;
+    abstract public function getSequences(string $collection, array $documents): array;
 
     /**
      * Get max STRING limit
-     *
-     * @return int
      */
     abstract public function getLimitForString(): int;
 
     /**
      * Get max INT limit
-     *
-     * @return int
      */
     abstract public function getLimitForInt(): int;
 
@@ -935,435 +882,234 @@ abstract public function getLimitForBigInt(): int;
 
     /**
      * Get maximum attributes limit.
-     *
-     * @return int
      */
     abstract public function getLimitForAttributes(): int;
 
     /**
      * Get maximum index limit.
-     *
-     * @return int
      */
     abstract public function getLimitForIndexes(): int;
 
     /**
-     * @return int
+     * Get the maximum index key length in bytes.
      */
     abstract public function getMaxIndexLength(): int;
 
     /**
      * Get the maximum VARCHAR length for this adapter
-     *
-     * @return int
      */
     abstract public function getMaxVarcharLength(): int;
 
     /**
      * Get the maximum UID length for this adapter
-     *
-     * @return int
      */
     abstract public function getMaxUIDLength(): int;
 
     /**
      * Get the minimum supported DateTime value
-     *
-     * @return \DateTime
-     */
-    abstract public function getMinDateTime(): \DateTime;
-
-    /**
-     * Get the primitive type of the primary key type for this adapter
-     *
-     * @return string
      */
-    abstract public function getIdAttributeType(): string;
+    abstract public function getMinDateTime(): DateTime;
 
     /**
      * Get the maximum supported DateTime value
-     *
-     * @return \DateTime
      */
-    public function getMaxDateTime(): \DateTime
+    public function getMaxDateTime(): DateTime
     {
-        return new \DateTime('9999-12-31 23:59:59');
+        return new DateTime('9999-12-31 23:59:59');
     }
 
     /**
-     * Is schemas supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForSchemas(): bool;
-
-    /**
-     * Are attributes supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForAttributes(): bool;
-
-    /**
-     * Are schema attributes supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForSchemaAttributes(): bool;
-
-    /**
-     * Are schema indexes supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForSchemaIndexes(): bool;
-
-    /**
-     * Is index supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForIndex(): bool;
-
-    /**
-     * Is indexing array supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForIndexArray(): bool;
-
-    /**
-     * Is cast index as array supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForCastIndexArray(): bool;
-
-    /**
-     * Is unique index supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForUniqueIndex(): bool;
-
-    /**
-     * Is fulltext index supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForFulltextIndex(): bool;
-
-    /**
-     * Is fulltext wildcard supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForFulltextWildcardIndex(): bool;
-
-
-    /**
-     * Does the adapter handle casting?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForCasting(): bool;
-
-    /**
-     * Does the adapter handle array Contains?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForQueryContains(): bool;
-
-    /**
-     * Are timeouts supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForTimeouts(): bool;
-
-    /**
-     * Are relationships supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForRelationships(): bool;
-
-    abstract public function getSupportForUpdateLock(): bool;
-
-    /**
-     * Are batch operations supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForBatchOperations(): bool;
-
-    /**
-     * Is attribute resizing supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForAttributeResizing(): bool;
-
-    /**
-     * Is get connection id supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForGetConnectionId(): bool;
-
-    /**
-     * Is upserting supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForUpserts(): bool;
-
-    /**
-     * Is upsert via arbitrary unique indexes supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForUpsertOnUniqueIndex(): bool;
-
-    /**
-     * Is vector type supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForVectors(): bool;
-
-    /**
-     * Is Cache Fallback supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForCacheSkipOnFailure(): bool;
-
-    /**
-     * @return bool
+     * Get the primitive type of the primary key type for this adapter
      */
-    abstract public function getSupportForCaching(): bool;
+    abstract public function getIdAttributeType(): string;
 
     /**
-     * Is reconnection supported?
+     * Get Collection Size of the raw data
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForReconnection(): bool;
+    abstract public function getSizeOfCollection(string $collection): int;
 
     /**
-     * Is hostname supported?
+     * Get Collection Size on the disk
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForHostname(): bool;
+    abstract public function getSizeOfCollectionOnDisk(string $collection): int;
 
     /**
-     * Is creating multiple attributes in a single query supported?
-     *
-     * @return bool
+     * Get maximum width, in bytes, allowed for a SQL row
+     * Return 0 when no restrictions apply
      */
-    abstract public function getSupportForBatchCreateAttributes(): bool;
+    abstract public function getDocumentSizeLimit(): int;
 
     /**
-     * Is spatial attributes supported?
-     *
-     * @return bool
+     * Estimate maximum number of bytes required to store a document in $collection.
+     * Byte requirement varies based on column type and size.
+     * Needed to satisfy MariaDB/MySQL row width limit.
+     * Return 0 when no restrictions apply to row width
      */
-    abstract public function getSupportForSpatialAttributes(): bool;
+    abstract public function getAttributeWidth(Document $collection): int;
 
     /**
-     * Are object (JSON) attributes supported?
-     *
-     * @return bool
+     * Get current attribute count from collection document
      */
-    abstract public function getSupportForObject(): bool;
+    abstract public function getCountOfAttributes(Document $collection): int;
 
     /**
-     * Are object (JSON) indexes supported?
-     *
-     * @return bool
+     * Get current index count from collection document
      */
-    abstract public function getSupportForObjectIndexes(): bool;
+    abstract public function getCountOfIndexes(Document $collection): int;
 
     /**
-     * Does the adapter support null values in spatial indexes?
-     *
-     * @return bool
+     * Returns number of attributes used by default.
      */
-    abstract public function getSupportForSpatialIndexNull(): bool;
+    abstract public function getCountOfDefaultAttributes(): int;
 
     /**
-     * Does the adapter support operators?
-     *
-     * @return bool
+     * Returns number of indexes used by default.
      */
-    abstract public function getSupportForOperators(): bool;
+    abstract public function getCountOfDefaultIndexes(): int;
 
     /**
-     * Adapter supports optional spatial attributes with existing rows.
+     * Get list of keywords that cannot be used
      *
-     * @return bool
+     * @return array<string>
      */
-    abstract public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool;
+    abstract public function getKeywords(): array;
 
     /**
-     * Does the adapter support order attribute in spatial indexes?
+     * Get List of internal index keys names
      *
-     * @return bool
+     * @return array<string>
      */
-    abstract public function getSupportForSpatialIndexOrder(): bool;
+    abstract public function getInternalIndexesKeys(): array;
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForSpatialAxisOrder(): bool;
+    protected function getInternalKeyForAttribute(string $attribute): string
+    {
+        return Storage::column($attribute);
+    }
 
     /**
-     * Does the adapter includes boundary during spatial contains?
+     * Get the query to check for tenant when in shared tables mode
      *
-     * @return bool
+     * @param  string  $collection  The collection being queried
+     * @param  string  $alias  The alias of the parent collection if in a subquery
      */
-    abstract public function getSupportForBoundaryInclusiveContains(): bool;
+    abstract public function getTenantQuery(string $collection, string $alias = ''): string;
 
     /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
-     *
-     * @return bool
+     * Handle non utf characters supported?
      */
-    abstract public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool;
+    public function getSupportNonUtfCharacters(): bool
+    {
+        return false;
+    }
 
     /**
-     * Does the adapter support multiple fulltext indexes?
+     * Process-lifetime cache for {@see self::filter()}. Keys are referentially
+     * stable across the request lifetime and frequently re-queried per-row, so
+     * caching the regex result amortizes the preg_replace cost across all
+     * decode/encode/build passes. Bounded to avoid unbounded growth from
+     * unusual input.
      *
-     * @return bool
+     * @var array<string, string>
      */
-    abstract public function getSupportForMultipleFulltextIndexes(): bool;
+    private static array $filteredKeyCache = [];
 
+    private const FILTERED_KEY_CACHE_LIMIT = 4096;
 
     /**
-     * Does the adapter support identical indexes?
+     * Filter Keys
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForIdenticalIndexes(): bool;
+    public function filter(string $value): string
+    {
+        if (isset(self::$filteredKeyCache[$value])) {
+            return self::$filteredKeyCache[$value];
+        }
 
-    /**
-     * Does the adapter support random order by?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForOrderRandom(): bool;
+        $filtered = \preg_replace("/[^A-Za-z0-9_\-]/", '', $value);
 
-    /**
-     * Get current attribute count from collection document
-     *
-     * @param Document $collection
-     * @return int
-     */
-    abstract public function getCountOfAttributes(Document $collection): int;
+        if (\is_null($filtered)) {
+            throw new DatabaseException('Failed to filter key');
+        }
 
-    /**
-     * Get current index count from collection document
-     *
-     * @param Document $collection
-     * @return int
-     */
-    abstract public function getCountOfIndexes(Document $collection): int;
+        if (\count(self::$filteredKeyCache) >= self::FILTERED_KEY_CACHE_LIMIT) {
+            self::$filteredKeyCache = [];
+        }
 
-    /**
-     * Returns number of attributes used by default.
-     *
-     * @return int
-     */
-    abstract public function getCountOfDefaultAttributes(): int;
+        return self::$filteredKeyCache[$value] = $filtered;
+    }
 
     /**
-     * Returns number of indexes used by default.
+     * Apply all write hooks' decorateRow to a row.
      *
-     * @return int
+     * @param  array<string, mixed>  $row
+     * @param  array<string, mixed>  $metadata
+     * @return array<string, mixed>
      */
-    abstract public function getCountOfDefaultIndexes(): int;
+    protected function decorateRow(array $row, array $metadata): array
+    {
+        foreach ($this->writeHooks as $hook) {
+            $row = $hook->decorateRow($row, $metadata);
+        }
 
-    /**
-     * Get maximum width, in bytes, allowed for a SQL row
-     * Return 0 when no restrictions apply
-     *
-     * @return int
-     */
-    abstract public function getDocumentSizeLimit(): int;
+        return $row;
+    }
 
     /**
-     * Estimate maximum number of bytes required to store a document in $collection.
-     * Byte requirement varies based on column type and size.
-     * Needed to satisfy MariaDB/MySQL row width limit.
-     * Return 0 when no restrictions apply to row width
+     * Run all write hooks concurrently when more than one is registered,
+     * otherwise run sequentially. The provided callable receives a single
+     * Write hook instance.
      *
-     * @param Document $collection
-     * @return int
+     * @param callable(Write): void $fn
      */
-    abstract public function getAttributeWidth(Document $collection): int;
+    protected function runWriteHooks(callable $fn): void
+    {
+        foreach ($this->writeHooks as $hook) {
+            $fn($hook);
+        }
+    }
 
     /**
-     * Get list of keywords that cannot be used
-     *
-     * @return array<string>
+     * @return array<string, mixed>
      */
-    abstract public function getKeywords(): array;
+    protected function documentMetadata(Document $document): array
+    {
+        return ['id' => $document->getId(), 'tenant' => $document->getTenant()];
+    }
 
     /**
      * Get an attribute projection given a list of selected attributes
      *
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
+     * @param  array<string>  $selections
      */
     abstract protected function getAttributeProjection(array $selections, string $prefix): mixed;
 
     /**
      * Get all selected attributes from queries
      *
-     * @param Query[] $queries
-     * @return string[]
+     * @param  array<Query>  $queries
+     * @return array<string>
      */
     protected function getAttributeSelections(array $queries): array
     {
         $selections = [];
 
         foreach ($queries as $query) {
-            switch ($query->getMethod()) {
-                case Query::TYPE_SELECT:
-                    foreach ($query->getValues() as $value) {
-                        $selections[] = $value;
-                    }
-                    break;
+            if ($query->getMethod() === Method::Select) {
+                foreach ($query->getValues() as $value) {
+                    /** @var string $value */
+                    $selections[] = $value;
+                }
             }
         }
 
         return $selections;
     }
 
-    /**
-     * Filter Keys
-     *
-     * @param string $value
-     * @return string
-     * @throws DatabaseException
-     */
-    public function filter(string $value): string
-    {
-        $value = \preg_replace("/[^A-Za-z0-9_\-]/", '', $value);
-
-        if (\is_null($value)) {
-            throw new DatabaseException('Failed to filter key');
-        }
-
-        return $value;
-    }
-
     protected function escapeWildcards(string $value): string
     {
         $wildcards = [
@@ -1381,7 +1127,7 @@ protected function escapeWildcards(string $value): string
             ')',
             '{',
             '}',
-            '|'
+            '|',
         ];
 
         foreach ($wildcards as $wildcard) {
@@ -1392,266 +1138,12 @@ protected function escapeWildcards(string $value): string
     }
 
     /**
-     * Increase or decrease attribute value
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $attribute
-     * @param int|float $value
-     * @param string $updatedAt
-     * @param int|float|null $min
-     * @param int|float|null $max
-     * @return bool
-     * @throws Exception
-     */
-    abstract public function increaseDocumentAttribute(
-        string $collection,
-        string $id,
-        string $attribute,
-        int|float $value,
-        string $updatedAt,
-        int|float|null $min = null,
-        int|float|null $max = null
-    ): bool;
-
-    /**
-     * Returns the connection ID identifier
-     *
-     * @return string
-     */
-    abstract public function getConnectionId(): string;
-
-    /**
-     * Get List of internal index keys names
-     *
-     * @return array<string>
-     */
-    abstract public function getInternalIndexesKeys(): array;
-
-    /**
-     * Get Schema Attributes
-     *
-     * @param string $collection
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    abstract public function getSchemaAttributes(string $collection): array;
-
-    /**
-     * Get Schema Indexes
-     *
-     * Returns physical index definitions from the database schema.
-     *
-     * @param string $collection
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    abstract public function getSchemaIndexes(string $collection): array;
-
-    /**
-     * Get the expected column type for a given attribute type.
-     *
-     * Returns the database-native column type string (e.g. "VARCHAR(255)", "BIGINT")
-     * that would be used when creating a column for the given attribute parameters.
-     * Returns an empty string if the adapter does not support this operation.
-     *
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param bool $required
-     * @return string
-     * @throws \Utopia\Database\Exception For unknown types on adapters that support column-type resolution.
-     */
-    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
-    {
-        return '';
-    }
-
-    /**
-     * Get the query to check for tenant when in shared tables mode
-     *
-     * @param string $collection   The collection being queried
-     * @param string $alias  The alias of the parent collection if in a subquery
-     * @return string
+     * Quote a string
      */
-    abstract public function getTenantQuery(string $collection, string $alias = ''): string;
+    abstract protected function quote(string $string): string;
 
-    /**
-     * @param mixed $stmt
-     * @return bool
-     */
     abstract protected function execute(mixed $stmt): bool;
 
-    /**
-     * Decode a WKB or textual POINT into [x, y]
-     *
-     * @param string $wkb
-     * @return float[] Array with two elements: [x, y]
-     */
-    abstract public function decodePoint(string $wkb): array;
-
-    /**
-     * Decode a WKB or textual LINESTRING into [[x1, y1], [x2, y2], ...]
-     *
-     * @param string $wkb
-     * @return float[][] Array of points, each as [x, y]
-     */
-    abstract public function decodeLinestring(string $wkb): array;
-
-    /**
-     * Decode a WKB or textual POLYGON into [[[x1, y1], [x2, y2], ...], ...]
-     *
-     * @param string $wkb
-     * @return float[][][] Array of rings, each ring is an array of points [x, y]
-     */
-    abstract public function decodePolygon(string $wkb): array;
-
-    public function getSupportForUnsignedBigInt(): bool
-    {
-        return false;
-    }
-
-    /**
-        * Returns the document after casting
-        * @param Document $collection
-        * @param Document $document
-        * @return Document
-        */
-    abstract public function castingBefore(Document $collection, Document $document): Document;
-
-    /**
-     * Returns the document after casting
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     */
-    abstract public function castingAfter(Document $collection, Document $document): Document;
-
-    /**
-     * Is internal casting supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForInternalCasting(): bool;
-
-    /**
-     * Is UTC casting supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForUTCCasting(): bool;
-
-    /**
-    * Set UTC Datetime
-    *
-    * @param string $value
-    * @return mixed
-    */
-    abstract public function setUTCDatetime(string $value): mixed;
-
-    /**
-    * Set support for attributes
-    *
-    * @param bool $support
-    * @return bool
-    */
-    abstract public function setSupportForAttributes(bool $support): bool;
-
-    /**
-     * Does the adapter require booleans to be converted to integers (0/1)?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForIntegerBooleans(): bool;
-
-    /**
-     * Does the adapter have support for ALTER TABLE locking modes?
-     *
-     * When enabled, adapters can specify lock behavior (e.g., LOCK=SHARED)
-     * during ALTER TABLE operations to control concurrent access.
-     *
-     * @return bool
-     */
-    abstract public function getSupportForAlterLocks(): bool;
-
-    /**
-     * @param bool $enable
-     *
-     * @return $this
-     */
-    public function enableAlterLocks(bool $enable): self
-    {
-        $this->alterLocks = $enable;
-
-        return $this;
-    }
-
-    /**
-     * Handle non utf characters supported?
-     *
-     * @return bool
-     */
-    abstract public function getSupportNonUtfCharacters(): bool;
-
-    /**
-     * Does the adapter support trigram index?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForTrigramIndex(): bool;
-
-    /**
-     * Is PCRE regex supported?
-     * PCRE (Perl Compatible Regular Expressions) supports \b for word boundaries
-     *
-     * @return bool
-     */
-    abstract public function getSupportForPCRERegex(): bool;
-
-    /**
-     * Is POSIX regex supported?
-     * POSIX regex uses \y for word boundaries instead of \b
-     *
-     * @return bool
-     */
-    abstract public function getSupportForPOSIXRegex(): bool;
-
-    /**
-     * Is regex supported at all?
-     * Returns true if either PCRE or POSIX regex is supported
-     *
-     * @return bool
-     */
-    public function getSupportForRegex(): bool
-    {
-        return $this->getSupportForPCRERegex() || $this->getSupportForPOSIXRegex();
-    }
-
-    /**
-     * Are ttl indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Does the adapter support transaction retries?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForTransactionRetries(): bool;
-
-    /**
-     * Does the adapter support nested transactions?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForNestedTransactions(): bool;
-
     /**
      * @return mixed
      */
diff --git a/src/Database/Adapter/Feature/Attributes.php b/src/Database/Adapter/Feature/Attributes.php
new file mode 100644
index 0000000000..9594f12634
--- /dev/null
+++ b/src/Database/Adapter/Feature/Attributes.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Attribute;
+
+/**
+ * Defines attribute management operations for a database adapter.
+ */
+interface Attributes
+{
+    /**
+     * Create a new attribute in a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param Attribute $attribute The attribute to create.
+     * @return bool True on success.
+     */
+    public function createAttribute(string $collection, Attribute $attribute): bool;
+
+    /**
+     * Create multiple attributes in a collection at once.
+     *
+     * @param string $collection The collection identifier.
+     * @param array<Attribute> $attributes The attributes to create.
+     * @return bool True on success.
+     */
+    public function createAttributes(string $collection, array $attributes): bool;
+
+    /**
+     * Update an existing attribute in a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param Attribute $attribute The attribute with updated properties.
+     * @param string|null $newKey Optional new key to rename the attribute.
+     * @return bool True on success.
+     */
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool;
+
+    /**
+     * Delete an attribute from a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $id The attribute identifier to delete.
+     * @return bool True on success.
+     */
+    public function deleteAttribute(string $collection, string $id): bool;
+
+    /**
+     * Rename an attribute in a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $old The current attribute key.
+     * @param string $new The new attribute key.
+     * @return bool True on success.
+     */
+    public function renameAttribute(string $collection, string $old, string $new): bool;
+}
diff --git a/src/Database/Adapter/Feature/Collections.php b/src/Database/Adapter/Feature/Collections.php
new file mode 100644
index 0000000000..69d311fca0
--- /dev/null
+++ b/src/Database/Adapter/Feature/Collections.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Index;
+
+/**
+ * Defines collection lifecycle and inspection operations for a database adapter.
+ */
+interface Collections
+{
+    /**
+     * Create a new collection with optional attributes and indexes.
+     *
+     * @param string $name The collection name.
+     * @param array<Attribute> $attributes Initial attributes for the collection.
+     * @param array<Index> $indexes Initial indexes for the collection.
+     * @return bool True on success.
+     */
+    public function createCollection(string $name, array $attributes = [], array $indexes = []): bool;
+
+    /**
+     * Delete a collection by its identifier.
+     *
+     * @param string $id The collection identifier.
+     * @return bool True on success.
+     */
+    public function deleteCollection(string $id): bool;
+
+    /**
+     * Analyze a collection to update index statistics.
+     *
+     * @param string $collection The collection identifier.
+     * @return bool True on success.
+     */
+    public function analyzeCollection(string $collection): bool;
+
+    /**
+     * Get the logical data size of a collection in bytes.
+     *
+     * @param string $collection The collection identifier.
+     * @return int Size in bytes.
+     */
+    public function getSizeOfCollection(string $collection): int;
+
+    /**
+     * Get the on-disk storage size of a collection in bytes.
+     *
+     * @param string $collection The collection identifier.
+     * @return int Size in bytes.
+     */
+    public function getSizeOfCollectionOnDisk(string $collection): int;
+}
diff --git a/src/Database/Adapter/Feature/ColumnTypes.php b/src/Database/Adapter/Feature/ColumnTypes.php
new file mode 100644
index 0000000000..1bdad576f7
--- /dev/null
+++ b/src/Database/Adapter/Feature/ColumnTypes.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+/**
+ * Provides database-native column type resolution for a database adapter.
+ */
+interface ColumnTypes
+{
+    /**
+     * Get the expected column type for a given attribute type.
+     *
+     * @param string $type The attribute type.
+     * @param int $size The column size.
+     * @param bool $signed Whether the column is signed.
+     * @param bool $array Whether the column stores an array.
+     * @param bool $required Whether the column is required.
+     * @return string The database-native column type string.
+     */
+    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string;
+}
diff --git a/src/Database/Adapter/Feature/ConnectionId.php b/src/Database/Adapter/Feature/ConnectionId.php
new file mode 100644
index 0000000000..5d85ddb923
--- /dev/null
+++ b/src/Database/Adapter/Feature/ConnectionId.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+/**
+ * Provides the ability to retrieve the underlying database connection identifier.
+ */
+interface ConnectionId
+{
+    /**
+     * Get the unique identifier for the current database connection.
+     *
+     * @return string The connection identifier.
+     */
+    public function getConnectionId(): string;
+}
diff --git a/src/Database/Adapter/Feature/Databases.php b/src/Database/Adapter/Feature/Databases.php
new file mode 100644
index 0000000000..9d38aed768
--- /dev/null
+++ b/src/Database/Adapter/Feature/Databases.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+
+/**
+ * Defines database-level lifecycle operations for a database adapter.
+ */
+interface Databases
+{
+    /**
+     * Create a new database.
+     *
+     * @param string $name The database name.
+     * @return bool True on success.
+     */
+    public function create(string $name): bool;
+
+    /**
+     * Check whether a database or collection exists.
+     *
+     * @param string $database The database name.
+     * @param string|null $collection Optional collection name to check within the database.
+     * @return bool True if the database (or collection) exists.
+     */
+    public function exists(string $database, ?string $collection = null): bool;
+
+    /**
+     * List all databases.
+     *
+     * @return array<Document> Array of database documents.
+     */
+    public function list(): array;
+
+    /**
+     * Delete a database by name.
+     *
+     * @param string $name The database name.
+     * @return bool True on success.
+     */
+    public function delete(string $name): bool;
+}
diff --git a/src/Database/Adapter/Feature/Documents.php b/src/Database/Adapter/Feature/Documents.php
new file mode 100644
index 0000000000..ecee61bf4b
--- /dev/null
+++ b/src/Database/Adapter/Feature/Documents.php
@@ -0,0 +1,152 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Query;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\OrderDirection;
+
+/**
+ * Defines document CRUD, querying, and aggregation operations for a database adapter.
+ */
+interface Documents
+{
+    /**
+     * Get a single document by its identifier.
+     *
+     * @param Document $collection The collection document.
+     * @param string $id The document identifier.
+     * @param array<Query> $queries Optional queries for field selection.
+     * @param bool $forUpdate Whether to lock the document for update.
+     * @return Document The retrieved document.
+     */
+    public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document;
+
+    /**
+     * Create a new document in a collection.
+     *
+     * @param Document $collection The collection document.
+     * @param Document $document The document to create.
+     * @return Document The created document.
+     */
+    public function createDocument(Document $collection, Document $document): Document;
+
+    /**
+     * Create multiple documents in a collection at once.
+     *
+     * @param Document $collection The collection document.
+     * @param array<Document> $documents The documents to create.
+     * @return array<Document> The created documents.
+     */
+    public function createDocuments(Document $collection, array $documents): array;
+
+    /**
+     * Update an existing document in a collection.
+     *
+     * @param Document $collection The collection document.
+     * @param string $id The document identifier.
+     * @param Document $document The document with updated data.
+     * @param bool $skipPermissions Whether to skip permission checks.
+     * @return Document The updated document.
+     */
+    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document;
+
+    /**
+     * Update multiple documents matching the given criteria.
+     *
+     * @param Document $collection The collection document.
+     * @param Document $updates The fields to update.
+     * @param array<Document> $documents The documents to update.
+     * @return int The number of documents updated.
+     */
+    public function updateDocuments(Document $collection, Document $updates, array $documents): int;
+
+    /**
+     * Delete a document from a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $id The document identifier.
+     * @return bool True on success.
+     */
+    public function deleteDocument(string $collection, string $id): bool;
+
+    /**
+     * Delete multiple documents from a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param array<string> $sequences The document sequences to delete.
+     * @param array<string> $permissionIds The permission identifiers to clean up.
+     * @return int The number of documents deleted.
+     */
+    public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int;
+
+    /**
+     * Find documents in a collection matching the given queries and ordering.
+     *
+     * @param Document $collection The collection document.
+     * @param array<Query> $queries Filter queries.
+     * @param int|null $limit Maximum number of documents to return.
+     * @param int|null $offset Number of documents to skip.
+     * @param array<string> $orderAttributes Attributes to order by.
+     * @param array<OrderDirection> $orderTypes Direction for each order attribute.
+     * @param array<string, mixed> $cursor Cursor values for pagination.
+     * @param CursorDirection $cursorDirection Direction of cursor pagination.
+     * @param PermissionType $forPermission The permission type to check.
+     * @return array<Document> The matching documents.
+     */
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array;
+
+    /**
+     * Calculate the sum of an attribute's values across matching documents.
+     *
+     * @param Document $collection The collection document.
+     * @param string $attribute The attribute to sum.
+     * @param array<Query> $queries Optional filter queries.
+     * @param int|null $max Maximum number of documents to consider.
+     * @return float|int The sum result.
+     */
+    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int;
+
+    /**
+     * Count documents matching the given queries.
+     *
+     * @param Document $collection The collection document.
+     * @param array<Query> $queries Optional filter queries.
+     * @param int|null $max Maximum count to return.
+     * @return int The document count.
+     */
+    public function count(Document $collection, array $queries = [], ?int $max = null): int;
+
+    /**
+     * Increase or decrease a numeric attribute value on a document.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $id The document identifier.
+     * @param string $attribute The numeric attribute to modify.
+     * @param int|float|string $value The value to add (negative to decrease).
+     * @param string $updatedAt The timestamp to set as the updated time.
+     * @param int|float|string|null $min Optional minimum bound for the resulting value.
+     * @param int|float|string|null $max Optional maximum bound for the resulting value.
+     * @return bool True on success.
+     */
+    public function increaseDocumentAttribute(
+        string $collection,
+        string $id,
+        string $attribute,
+        int|float|string $value,
+        string $updatedAt,
+        int|float|string|null $min = null,
+        int|float|string|null $max = null
+    ): bool;
+
+    /**
+     * Retrieve internal sequence values for the given documents.
+     *
+     * @param string $collection The collection identifier.
+     * @param array<Document> $documents The documents to retrieve sequences for.
+     * @return array<Document> The documents with populated sequence values.
+     */
+    public function getSequences(string $collection, array $documents): array;
+}
diff --git a/src/Database/Adapter/Feature/Indexes.php b/src/Database/Adapter/Feature/Indexes.php
new file mode 100644
index 0000000000..14e649331c
--- /dev/null
+++ b/src/Database/Adapter/Feature/Indexes.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Index;
+
+/**
+ * Defines index management operations for a database adapter.
+ */
+interface Indexes
+{
+    /**
+     * Create an index on a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param Index $index The index definition.
+     * @param array<string,string> $indexAttributeTypes Mapping of attribute names to their types.
+     * @param array<string, mixed> $collation Optional collation settings for the index.
+     * @return bool True on success.
+     */
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool;
+
+    /**
+     * Delete an index from a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $id The index identifier.
+     * @return bool True on success.
+     */
+    public function deleteIndex(string $collection, string $id): bool;
+
+    /**
+     * Rename an index in a collection.
+     *
+     * @param string $collection The collection identifier.
+     * @param string $old The current index name.
+     * @param string $new The new index name.
+     * @return bool True on success.
+     */
+    public function renameIndex(string $collection, string $old, string $new): bool;
+
+    /**
+     * Get the keys of all internal indexes used by the adapter.
+     *
+     * @return array<string> The internal index keys.
+     */
+    public function getInternalIndexesKeys(): array;
+}
diff --git a/src/Database/Adapter/Feature/InternalCasting.php b/src/Database/Adapter/Feature/InternalCasting.php
new file mode 100644
index 0000000000..37a5685543
--- /dev/null
+++ b/src/Database/Adapter/Feature/InternalCasting.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+
+/**
+ * Defines hooks for casting document values before and after database operations.
+ */
+interface InternalCasting
+{
+    /**
+     * Cast document attribute values before writing to the database.
+     *
+     * @param Document $collection The collection document.
+     * @param Document $document The document to cast.
+     * @return Document The document with cast values.
+     */
+    public function castingBefore(Document $collection, Document $document): Document;
+
+    /**
+     * Cast document attribute values after reading from the database.
+     *
+     * @param Document $collection The collection document.
+     * @param Document $document The document to cast.
+     * @return Document The document with cast values.
+     */
+    public function castingAfter(Document $collection, Document $document): Document;
+}
diff --git a/src/Database/Adapter/Feature/QueryBuilder.php b/src/Database/Adapter/Feature/QueryBuilder.php
new file mode 100644
index 0000000000..89ac558bc5
--- /dev/null
+++ b/src/Database/Adapter/Feature/QueryBuilder.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Query\Builder;
+use Utopia\Query\Schema;
+
+/**
+ * Provides access to the query builder and schema for a database adapter.
+ */
+interface QueryBuilder
+{
+    /**
+     * Get a query builder for the given collection.
+     *
+     * @param string $collection The collection identifier.
+     * @return Builder The query builder.
+     */
+    public function getBuilder(string $collection): Builder;
+
+    /**
+     * Get the query schema for this adapter.
+     *
+     * @return Schema The query schema.
+     */
+    public function getSchema(): Schema;
+}
diff --git a/src/Database/Adapter/Feature/RawQuery.php b/src/Database/Adapter/Feature/RawQuery.php
new file mode 100644
index 0000000000..f7af7a847a
--- /dev/null
+++ b/src/Database/Adapter/Feature/RawQuery.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+
+/**
+ * Defines raw query and mutation operations for a database adapter.
+ */
+interface RawQuery
+{
+    /**
+     * Execute a raw query and return results as Documents.
+     *
+     * @param string $query The raw query string.
+     * @param array<mixed> $bindings Parameter bindings for prepared statements.
+     * @return array<Document> The query results as Document objects.
+     */
+    public function rawQuery(string $query, array $bindings = []): array;
+
+    /**
+     * Execute a raw mutation and return the number of affected rows.
+     *
+     * @param string $query The raw mutation string.
+     * @param array<mixed> $bindings Parameter bindings for prepared statements.
+     * @return int The number of affected rows.
+     */
+    public function rawMutation(string $query, array $bindings = []): int;
+}
diff --git a/src/Database/Adapter/Feature/Relationships.php b/src/Database/Adapter/Feature/Relationships.php
new file mode 100644
index 0000000000..1fe5785a23
--- /dev/null
+++ b/src/Database/Adapter/Feature/Relationships.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Relationship;
+
+/**
+ * Defines relationship management operations for a database adapter.
+ */
+interface Relationships
+{
+    /**
+     * Create a relationship between collections.
+     *
+     * @param Relationship $relationship The relationship definition.
+     * @return bool True on success.
+     */
+    public function createRelationship(Relationship $relationship): bool;
+
+    /**
+     * Update an existing relationship, optionally renaming its keys.
+     *
+     * @param Relationship $relationship The relationship with updated properties.
+     * @param string|null $newKey Optional new key for the relationship.
+     * @param string|null $newTwoWayKey Optional new key for the inverse side.
+     * @return bool True on success.
+     */
+    public function updateRelationship(Relationship $relationship, ?string $newKey = null, ?string $newTwoWayKey = null): bool;
+
+    /**
+     * Delete a relationship between collections.
+     *
+     * @param Relationship $relationship The relationship to delete.
+     * @return bool True on success.
+     */
+    public function deleteRelationship(Relationship $relationship): bool;
+}
diff --git a/src/Database/Adapter/Feature/SchemaAttributes.php b/src/Database/Adapter/Feature/SchemaAttributes.php
new file mode 100644
index 0000000000..518eaeba51
--- /dev/null
+++ b/src/Database/Adapter/Feature/SchemaAttributes.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+
+/**
+ * Provides the ability to retrieve the schema-level attributes of a collection.
+ */
+interface SchemaAttributes
+{
+    /**
+     * Get the schema attributes defined on a collection in the underlying database.
+     *
+     * @param string $collection The collection identifier.
+     * @return array<Document> The attribute documents describing the schema.
+     */
+    public function getSchemaAttributes(string $collection): array;
+}
diff --git a/src/Database/Adapter/Feature/SchemaIndexes.php b/src/Database/Adapter/Feature/SchemaIndexes.php
new file mode 100644
index 0000000000..632735097b
--- /dev/null
+++ b/src/Database/Adapter/Feature/SchemaIndexes.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Document;
+
+/**
+ * Provides the ability to retrieve the schema-level indexes of a collection.
+ */
+interface SchemaIndexes
+{
+    /**
+     * Get the schema indexes defined on a collection in the underlying database.
+     *
+     * @param string $collection The collection identifier.
+     * @return array<Document> The index documents describing the schema.
+     */
+    public function getSchemaIndexes(string $collection): array;
+}
diff --git a/src/Database/Adapter/Feature/Spatial.php b/src/Database/Adapter/Feature/Spatial.php
new file mode 100644
index 0000000000..81c120bc95
--- /dev/null
+++ b/src/Database/Adapter/Feature/Spatial.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+/**
+ * Defines spatial geometry decoding operations for a database adapter.
+ */
+interface Spatial
+{
+    /**
+     * Decode a WKB-encoded point into coordinates.
+     *
+     * @param string $wkb The Well-Known Binary representation.
+     * @return array<float> The point as [longitude, latitude].
+     */
+    public function decodePoint(string $wkb): array;
+
+    /**
+     * Decode a WKB-encoded linestring into an array of coordinate pairs.
+     *
+     * @param string $wkb The Well-Known Binary representation.
+     * @return array<array<float>> Array of [longitude, latitude] pairs.
+     */
+    public function decodeLinestring(string $wkb): array;
+
+    /**
+     * Decode a WKB-encoded polygon into an array of rings, each containing coordinate pairs.
+     *
+     * @param string $wkb The Well-Known Binary representation.
+     * @return array<array<array<float>>> Array of rings, each an array of [longitude, latitude] pairs.
+     */
+    public function decodePolygon(string $wkb): array;
+}
diff --git a/src/Database/Adapter/Feature/Timeouts.php b/src/Database/Adapter/Feature/Timeouts.php
new file mode 100644
index 0000000000..c5694dcafc
--- /dev/null
+++ b/src/Database/Adapter/Feature/Timeouts.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Event;
+
+/**
+ * Provides the ability to set query execution timeouts on a database adapter.
+ */
+interface Timeouts
+{
+    /**
+     * Set a timeout for database operations.
+     *
+     * @param int $milliseconds The timeout duration in milliseconds.
+     * @param Event $event The event scope to apply the timeout to.
+     * @return void
+     */
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void;
+
+    /**
+     * Clear a timeout for database operations.
+     *
+     * @param Event $event The event scope to clear the timeout from.
+     * @return void
+     */
+    public function clearTimeout(Event $event = Event::All): void;
+}
diff --git a/src/Database/Adapter/Feature/Transactions.php b/src/Database/Adapter/Feature/Transactions.php
new file mode 100644
index 0000000000..f91fd64cf5
--- /dev/null
+++ b/src/Database/Adapter/Feature/Transactions.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+/**
+ * Defines transaction control operations for a database adapter.
+ */
+interface Transactions
+{
+    /**
+     * Begin a new database transaction.
+     *
+     * @return bool True on success.
+     */
+    public function startTransaction(): bool;
+
+    /**
+     * Commit the current database transaction.
+     *
+     * @return bool True on success.
+     */
+    public function commitTransaction(): bool;
+
+    /**
+     * Roll back the current database transaction.
+     *
+     * @return bool True on success.
+     */
+    public function rollbackTransaction(): bool;
+}
diff --git a/src/Database/Adapter/Feature/UTCCasting.php b/src/Database/Adapter/Feature/UTCCasting.php
new file mode 100644
index 0000000000..a962a90fb8
--- /dev/null
+++ b/src/Database/Adapter/Feature/UTCCasting.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+/**
+ * Provides the ability to cast datetime strings to UTC for storage.
+ */
+interface UTCCasting
+{
+    /**
+     * Convert a datetime string to a UTC representation suitable for the database.
+     *
+     * @param string $value The datetime string to convert.
+     * @return mixed The converted value in the adapter's native format.
+     */
+    public function setUTCDatetime(string $value): mixed;
+}
diff --git a/src/Database/Adapter/Feature/Upserts.php b/src/Database/Adapter/Feature/Upserts.php
new file mode 100644
index 0000000000..41e80bf80a
--- /dev/null
+++ b/src/Database/Adapter/Feature/Upserts.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Utopia\Database\Adapter\Feature;
+
+use Utopia\Database\Change;
+use Utopia\Database\Document;
+
+/**
+ * Defines upsert (insert-or-update) operations for a database adapter.
+ */
+interface Upserts
+{
+    /**
+     * Upsert multiple documents, inserting or updating based on a unique attribute.
+     *
+     * @param Document $collection The collection document.
+     * @param string $attribute The unique attribute used to determine insert vs update.
+     * @param array<Change> $changes The old/new document pairs to upsert.
+     * @return array<Document> The resulting documents after upsert.
+     */
+    public function upsertDocuments(Document $collection, string $attribute, array $changes): array;
+}
diff --git a/src/Database/Adapter/MariaDB.php b/src/Database/Adapter/MariaDB.php
index 6d2aac8ef7..36b6990aa9 100644
--- a/src/Database/Adapter/MariaDB.php
+++ b/src/Database/Adapter/MariaDB.php
@@ -3,9 +3,16 @@
 namespace Utopia\Database\Adapter;
 
 use Exception;
+use PDO;
 use PDOException;
+use PDOStatement;
+use Swoole\Database\PDOStatementProxy;
+use Throwable;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Character as CharacterException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
@@ -16,212 +23,244 @@
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Exception\Unique as UniqueException;
-use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
 use Utopia\Database\Query;
-
-class MariaDB extends SQL
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\MariaDB as MariaDBBuilder;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\Method;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\MySQL as MySQLSchema;
+
+/**
+ * Database adapter for MariaDB, extending the base SQL adapter with MariaDB-specific features.
+ */
+class MariaDB extends SQL implements Feature\ConnectionId, Feature\SchemaAttributes, Feature\SchemaIndexes, Feature\Spatial, Feature\Timeouts
 {
     /**
-     * Create Database
+     * Get the list of capabilities supported by the MariaDB adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::IntegerBooleans,
+            Capability::NumericCasting,
+            Capability::AlterLock,
+            Capability::JSONOverlaps,
+            Capability::FulltextWildcard,
+            Capability::PCRE,
+            Capability::SpatialIndexOrder,
+            Capability::OptionalSpatial,
+            Capability::Upserts,
+            Capability::UpsertOnUniqueIndex,
+            Capability::UnsignedBigInt,
+        ]);
+    }
+
+    /**
+     * Check whether the adapter supports storing non-UTF characters.
      *
-     * @param string $name
      * @return bool
-     * @throws Exception
-     * @throws PDOException
      */
-    public function create(string $name): bool
+    public function getSupportNonUtfCharacters(): bool
     {
-        $name = $this->filter($name);
+        return true;
+    }
 
-        if ($this->exists($name)) {
-            return true;
-        }
+    /**
+     * Get the current database connection ID.
+     *
+     * @return string
+     */
+    public function getConnectionId(): string
+    {
+        $result = $this->createBuilder()->fromNone()->selectRaw('CONNECTION_ID()')->build();
+        $stmt = $this->getPDO()->query($result->query);
 
-        $sql = "CREATE DATABASE `{$name}` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;";
+        if ($stmt === false) {
+            return '';
+        }
 
-        $sql = $this->trigger(Database::EVENT_DATABASE_CREATE, $sql);
+        $col = $stmt->fetchColumn();
 
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        return \is_scalar($col) ? (string) $col : '';
     }
 
     /**
-     * Delete Database
+     * Create Database
      *
-     * @param string $name
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function delete(string $name): bool
+    public function create(string $name): bool
     {
         $name = $this->filter($name);
 
-        $sql = "DROP DATABASE `{$name}`;";
+        if ($this->exists($name)) {
+            return true;
+        }
 
-        $sql = $this->trigger(Database::EVENT_DATABASE_DELETE, $sql);
+        $result = $this->createSchemaBuilder()->createDatabase($name);
+        $sql = $result->query;
 
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        return $this->executeStatement($sql, Event::DatabaseCreate);
     }
 
     /**
      * Create Collection
      *
-     * @param string $name
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     * @param  array<Index>  $indexes
+     *
      * @throws Exception
      * @throws PDOException
      */
     public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
     {
         $id = $this->filter($name);
+        $schema = $this->createSchemaBuilder();
+        $sharedTables = $this->sharedTables;
 
-        /** @var array<string> $attributeStrings */
-        $attributeStrings = [];
-
-        /** @var array<string> $indexStrings */
-        $indexStrings = [];
-
+        // Pre-build attribute hash for array lookups during index construction
         $hash = [];
-
-        foreach ($attributes as $key => $attribute) {
-            $attrId = $this->filter($attribute->getId());
+        foreach ($attributes as $attribute) {
+            $attrId = $this->filter($attribute->key);
             $hash[$attrId] = $attribute;
+        }
 
-            $attrType = $this->getSQLType(
-                $attribute->getAttribute('type'),
-                $attribute->getAttribute('size', 0),
-                $attribute->getAttribute('signed', true),
-                $attribute->getAttribute('array', false),
-                $attribute->getAttribute('required', false)
-            );
+        $table = $schema->table($this->getSQLTableRaw($id));
+        $table->id(Storage::SEQUENCE);
+        $table->string(Storage::UID, 255);
+        $table->datetime(Storage::CREATED_AT, 3)->nullable()->default(null);
+        $table->datetime(Storage::UPDATED_AT, 3)->nullable()->default(null);
+        $table->mediumText(Storage::PERMISSIONS)->nullable()->default(null);
+        $table->rawColumn('`'.Storage::VERSION.'` INT(11) UNSIGNED DEFAULT 1');
+
+        foreach ($attributes as $attribute) {
+            $attrId = $this->filter($attribute->key);
 
-            // Ignore relationships with virtual attributes
-            if ($attribute->getAttribute('type') === Database::VAR_RELATIONSHIP) {
-                $options = $attribute->getAttribute('options', []);
+            if ($attribute->type === ColumnType::Relationship) {
+                $options = $attribute->options ?? [];
                 $relationType = $options['relationType'] ?? null;
                 $twoWay = $options['twoWay'] ?? false;
                 $side = $options['side'] ?? null;
 
                 if (
-                    $relationType === Database::RELATION_MANY_TO_MANY
-                    || ($relationType === Database::RELATION_ONE_TO_ONE && !$twoWay && $side === Database::RELATION_SIDE_CHILD)
-                    || ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT)
-                    || ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD)
+                    $relationType === RelationType::ManyToMany->value
+                    || ($relationType === RelationType::OneToOne->value && ! $twoWay && $side === RelationSide::Child->value)
+                    || ($relationType === RelationType::OneToMany->value && $side === RelationSide::Parent->value)
+                    || ($relationType === RelationType::ManyToOne->value && $side === RelationSide::Child->value)
                 ) {
                     continue;
                 }
             }
 
-            $attributeStrings[$key] = "`{$attrId}` {$attrType}, ";
+            $attrType = $this->getSQLType(
+                $attribute->type,
+                $attribute->size,
+                $attribute->signed,
+                $attribute->array,
+                $attribute->required
+            );
+            $table->rawColumn("`{$attrId}` {$attrType}");
         }
 
-        foreach ($indexes as $key => $index) {
-            $indexId = $this->filter($index->getId());
-            $indexType = $index->getAttribute('type');
+        foreach ($indexes as $index) {
+            $indexId = $this->filter($index->key);
+            $indexType = $index->type;
+            $indexAttributes = $index->attributes;
+
+            $regularColumns = [];
+            $indexLengths = [];
+            $indexOrders = [];
+            $rawCastColumns = [];
 
-            $indexAttributes = $index->getAttribute('attributes');
             foreach ($indexAttributes as $nested => $attribute) {
-                $indexLength = $index->getAttribute('lengths')[$nested] ?? '';
-                $indexLength = (empty($indexLength)) ? '' : '(' . (int)$indexLength . ')';
-                $indexOrder = $index->getAttribute('orders')[$nested] ?? '';
-                if ($indexType === Database::INDEX_SPATIAL && !$this->getSupportForSpatialIndexOrder() && !empty($indexOrder)) {
+                $indexLength = $index->lengths[$nested] ?? '';
+                $indexOrder = Index::direction($index->orders[$nested] ?? null);
+
+                if ($indexType === IndexType::Spatial && ! $this->supports(Capability::SpatialIndexOrder) && ! empty($indexOrder)) {
                     throw new DatabaseException('Spatial indexes with explicit orders are not supported. Remove the orders to create this index.');
                 }
-                $indexAttribute = $this->getInternalKeyForAttribute($attribute);
-                $indexAttribute = $this->filter($indexAttribute);
 
-                if ($indexType === Database::INDEX_FULLTEXT) {
+                $indexAttribute = $this->filter($this->getInternalKeyForAttribute($attribute));
+
+                if ($indexType === IndexType::Fulltext) {
                     $indexOrder = '';
                 }
 
-                $indexAttributes[$nested] = "`{$indexAttribute}`{$indexLength} {$indexOrder}";
-
-                if (!empty($hash[$indexAttribute]['array']) && $this->getSupportForCastIndexArray()) {
-                    $indexAttributes[$nested] = '(CAST(`' . $indexAttribute . '` AS char(' . Database::MAX_ARRAY_INDEX_LENGTH . ') ARRAY))';
+                if (! empty($hash[$indexAttribute]->array) && $this->supports(Capability::CastIndexArray)) {
+                    $rawCastColumns[] = '(CAST(`'.$indexAttribute.'` AS char('.Database::MAX_ARRAY_INDEX_LENGTH.') ARRAY))';
+                } else {
+                    $regularColumns[] = $indexAttribute;
+                    if (! empty($indexLength)) {
+                        $indexLengths[$indexAttribute] = (int) $indexLength;
+                    }
+                    if (! empty($indexOrder)) {
+                        $indexOrders[$indexAttribute] = $indexOrder;
+                    }
                 }
             }
 
-            $indexAttributes = \implode(", ", $indexAttributes);
-
-            if ($this->sharedTables && $indexType !== Database::INDEX_FULLTEXT && $indexType !== Database::INDEX_SPATIAL) {
-                // Add tenant as first index column for best performance
-                $indexAttributes = "_tenant, {$indexAttributes}";
+            if ($sharedTables && $indexType !== IndexType::Fulltext && $indexType !== IndexType::Spatial) {
+                \array_unshift($regularColumns, Storage::TENANT);
             }
 
-            $indexStrings[$key] = "{$indexType} `{$indexId}` ({$indexAttributes}),";
+            $table->addIndex(
+                $indexId,
+                $regularColumns,
+                $indexType,
+                $indexLengths,
+                $indexOrders,
+                rawColumns: $rawCastColumns,
+            );
         }
 
-        $collection = "
-			CREATE TABLE {$this->getSQLTable($id)} (
-				_id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
-				_uid VARCHAR(255) NOT NULL,
-				_createdAt DATETIME(3) DEFAULT NULL,
-				_updatedAt DATETIME(3) DEFAULT NULL,
-				_permissions MEDIUMTEXT DEFAULT NULL,
-				PRIMARY KEY (_id),
-				" . \implode(' ', $attributeStrings) . "
-				" . \implode(' ', $indexStrings) . "
-		";
-
-        if ($this->sharedTables) {
-            $collection .= "
-            	_tenant INT(11) UNSIGNED DEFAULT NULL,
-				UNIQUE KEY _uid (_uid, _tenant),
-				KEY _created_at (_tenant, _createdAt),
-				KEY _updated_at (_tenant, _updatedAt),
-				KEY _tenant_id (_tenant, _id)
-			";
+        if ($sharedTables) {
+            $table->rawColumn(Storage::TENANT.' INT(11) UNSIGNED DEFAULT NULL');
+            $table->uniqueIndex([Storage::UID, Storage::TENANT], Storage::UID);
+            $table->index([Storage::TENANT, Storage::CREATED_AT], Storage::INDEX_CREATED_AT);
+            $table->index([Storage::TENANT, Storage::UPDATED_AT], Storage::INDEX_UPDATED_AT);
+            $table->index([Storage::TENANT, Storage::SEQUENCE], Storage::INDEX_TENANT_ID);
         } else {
-            $collection .= "
-				UNIQUE KEY _uid (_uid),
-				KEY _created_at (_createdAt),
-				KEY _updated_at (_updatedAt)
-			";
+            $table->uniqueIndex([Storage::UID], Storage::UID);
+            $table->index([Storage::CREATED_AT], Storage::INDEX_CREATED_AT);
+            $table->index([Storage::UPDATED_AT], Storage::INDEX_UPDATED_AT);
         }
 
-        $collection .= ")";
-        $collection = $this->trigger(Database::EVENT_COLLECTION_CREATE, $collection);
-
-        $permissions = "
-            CREATE TABLE {$this->getSQLTable($id . '_perms')} (
-                _id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
-                _type VARCHAR(12) NOT NULL,
-                _permission VARCHAR(255) NOT NULL,
-                _document VARCHAR(255) NOT NULL,
-                PRIMARY KEY (_id),
-        ";
-
-        if ($this->sharedTables) {
-            $permissions .= "
-                _tenant INT(11) UNSIGNED DEFAULT NULL,
-                UNIQUE INDEX _index1 (_document, _tenant, _type, _permission),
-                INDEX _permission (_tenant, _permission, _type)
-            ";
+        $collectionResult = $table->create();
+        $collection = $collectionResult->query;
+
+        $permsTable = $schema->table($this->getSQLTableRaw(Storage::permissionsTable($id)));
+        $permsTable->id(Storage::SEQUENCE);
+        $permsTable->string(Storage::PERM_TYPE, 12);
+        $permsTable->string(Storage::PERM_PERMISSION, 255);
+        $permsTable->string(Storage::PERM_DOCUMENT, 255);
+
+        if ($sharedTables) {
+            $permsTable->integer(Storage::TENANT)->unsigned()->nullable()->default(null);
+            $permsTable->uniqueIndex([Storage::PERM_DOCUMENT, Storage::TENANT, Storage::PERM_TYPE, Storage::PERM_PERMISSION], Storage::INDEX_1);
+            $permsTable->index([Storage::TENANT, Storage::PERM_PERMISSION, Storage::PERM_TYPE], Storage::PERM_PERMISSION);
         } else {
-            $permissions .= "
-                UNIQUE INDEX _index1 (_document, _type, _permission),
-                INDEX _permission (_permission, _type)
-            ";
+            $permsTable->uniqueIndex([Storage::PERM_DOCUMENT, Storage::PERM_TYPE, Storage::PERM_PERMISSION], Storage::INDEX_1);
+            $permsTable->index([Storage::PERM_PERMISSION, Storage::PERM_TYPE], Storage::PERM_PERMISSION);
         }
 
-        $permissions .= ")";
-        $permissions = $this->trigger(Database::EVENT_COLLECTION_CREATE, $permissions);
+        $permsResult = $permsTable->create();
+        $permissions = $permsResult->query;
 
         try {
-            $this->getPDO()
-                ->prepare($collection)
-                ->execute();
-
-            $this->getPDO()
-                ->prepare($permissions)
-                ->execute();
+            $this->executeStatement($collection, Event::CollectionCreate);
+            $this->executeStatement($permissions, Event::CollectionCreate);
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -229,97 +268,9 @@ public function createCollection(string $name, array $attributes = [], array $in
         return true;
     }
 
-    /**
-     * Get collection size on disk
-     *
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
-     */
-    public function getSizeOfCollectionOnDisk(string $collection): int
-    {
-        $collection = $this->filter($collection);
-        $collection = $this->getNamespace() . '_' . $collection;
-        $database = $this->getDatabase();
-        $name = $database . '/' . $collection;
-        $permissions = $database . '/' . $collection . '_perms';
-
-        $collectionSize = $this->getPDO()->prepare("
-            SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
-            FROM INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES
-            WHERE NAME = :name
-         ");
-
-        $permissionsSize = $this->getPDO()->prepare("
-            SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
-            FROM INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES
-            WHERE NAME = :permissions
-        ");
-
-        $collectionSize->bindParam(':name', $name);
-        $permissionsSize->bindParam(':permissions', $permissions);
-
-        try {
-            $collectionSize->execute();
-            $permissionsSize->execute();
-            $size = $collectionSize->fetchColumn() + $permissionsSize->fetchColumn();
-        } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
-        }
-
-        return $size;
-    }
-
-    /**
-     * Get Collection Size of the raw data
-     *
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
-     */
-    public function getSizeOfCollection(string $collection): int
-    {
-        $collection = $this->filter($collection);
-        $collection = $this->getNamespace() . '_' . $collection;
-        $database = $this->getDatabase();
-        $permissions = $collection . '_perms';
-
-        // Both tables in one round trip. Keep the equality predicates: LIKE and IN are
-        // not indexed here, they scan every table in the schema.
-        $statement = $this->getPDO()->prepare("
-            SELECT SUM(size) FROM (
-                SELECT data_length + index_length AS size
-                FROM INFORMATION_SCHEMA.TABLES
-                WHERE table_name = :name AND
-                table_schema = :database_name
-                UNION ALL
-                SELECT data_length + index_length AS size
-                FROM INFORMATION_SCHEMA.TABLES
-                WHERE table_name = :permissions AND
-                table_schema = :database_permissions
-            ) AS sizes
-        ");
-
-        $statement->bindParam(':name', $collection);
-        $statement->bindParam(':permissions', $permissions);
-        $statement->bindParam(':database_name', $database);
-        $statement->bindParam(':database_permissions', $database);
-
-        try {
-            $statement->execute();
-            $size = $statement->fetchColumn();
-        } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
-        }
-
-        return (int) $size;
-    }
-
     /**
      * Delete collection
      *
-     * @param string $id
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
@@ -327,14 +278,14 @@ public function deleteCollection(string $id): bool
     {
         $id = $this->filter($id);
 
-        $sql = "DROP TABLE {$this->getSQLTable($id)}, {$this->getSQLTable($id . '_perms')};";
+        $schema = $this->createSchemaBuilder();
+        $mainResult = $schema->table($this->getSQLTableRaw($id))->drop();
+        $permsResult = $schema->table($this->getSQLTableRaw(Storage::permissionsTable($id)))->drop();
 
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
+        $sql = $mainResult->query.'; '.$permsResult->query;
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            return $this->executeStatement($sql, Event::CollectionDelete);
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -343,441 +294,264 @@ public function deleteCollection(string $id): bool
     /**
      * Analyze a collection updating it's metadata on the database engine
      *
-     * @param string $collection
-     * @return bool
      * @throws DatabaseException
      */
     public function analyzeCollection(string $collection): bool
     {
         $name = $this->filter($collection);
 
-        $sql = "ANALYZE TABLE {$this->getSQLTable($name)}";
+        $result = $this->createSchemaBuilder()->analyzeTable($this->getSQLTableRaw($name));
+        $sql = $result->query;
 
-        $stmt = $this->getPDO()->prepare($sql);
-        return $stmt->execute();
+        return $this->executeStatement($sql, Event::CollectionUpdate);
     }
 
     /**
-     * Get Schema Attributes
+     * Get collection size on disk
      *
-     * @param string $collection
-     * @return array<Document>
      * @throws DatabaseException
      */
-    public function getSchemaAttributes(string $collection): array
+    public function getSizeOfCollectionOnDisk(string $collection): int
     {
-        $schema = $this->getDatabase();
-        $collection = $this->getNamespace().'_'.$this->filter($collection);
+        $collection = $this->filter($collection);
+        $collection = $this->getNamespace().'_'.$collection;
+        $database = $this->getDatabase();
+        $name = $database.'/'.$collection;
+        $permissions = $database.'/'.Storage::permissionsTable($collection);
 
-        try {
-            $stmt = $this->getPDO()->prepare('
-                SELECT
-                COLUMN_NAME as _id,
-                COLUMN_DEFAULT as columnDefault,
-                IS_NULLABLE as isNullable,
-                DATA_TYPE as dataType,
-                CHARACTER_MAXIMUM_LENGTH as characterMaximumLength,
-                NUMERIC_PRECISION as numericPrecision,
-                NUMERIC_SCALE as numericScale,
-                DATETIME_PRECISION as datetimePrecision,
-                COLUMN_TYPE as columnType,
-                COLUMN_KEY as columnKey,
-                EXTRA as extra
-                FROM INFORMATION_SCHEMA.COLUMNS
-                WHERE TABLE_SCHEMA = :schema AND TABLE_NAME = :table
-            ');
-            $stmt->bindParam(':schema', $schema);
-            $stmt->bindParam(':table', $collection);
-            $stmt->execute();
-            $results = $stmt->fetchAll();
-            $stmt->closeCursor();
+        $builder = $this->createBuilder();
 
-            foreach ($results as $index => $document) {
-                $document['$id'] = $document['_id'];
-                unset($document['_id']);
+        $collectionResult = $builder
+            ->from('INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES')
+            ->selectRaw('SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)')
+            ->filter([BaseQuery::equal('NAME', [$name])])
+            ->build();
 
-                $results[$index] = new Document($document);
-            }
+        $permissionsResult = $builder->reset()
+            ->from('INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES')
+            ->selectRaw('SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)')
+            ->filter([BaseQuery::equal('NAME', [$permissions])])
+            ->build();
 
-            return $results;
+        $collectionSize = $this->executeResult($collectionResult, Event::CollectionRead);
+        $permissionsSize = $this->executeResult($permissionsResult, Event::CollectionRead);
 
-        } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get schema attributes', $e->getCode(), $e);
+        foreach ($collectionResult->bindings as $i => $v) {
+            $collectionSize->bindValue($i + 1, $v);
         }
-    }
-
-    /**
-     * Update Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $newKey
-     * @param bool $required
-     * @return bool
-     * @throws DatabaseException
-     */
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
-    {
-        $name = $this->filter($collection);
-        $id = $this->filter($id);
-        $newKey = empty($newKey) ? null : $this->filter($newKey);
-        $type = $this->getSQLType($type, $size, $signed, $array, $required);
-        if (!empty($newKey)) {
-            $sql = "ALTER TABLE {$this->getSQLTable($name)} CHANGE COLUMN `{$id}` `{$newKey}` {$type};";
-        } else {
-            $sql = "ALTER TABLE {$this->getSQLTable($name)} MODIFY `{$id}` {$type};";
+        foreach ($permissionsResult->bindings as $i => $v) {
+            $permissionsSize->bindValue($i + 1, $v);
         }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
-
         try {
-            return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+            $this->execute($collectionSize);
+            $this->execute($permissionsSize);
+            $collSizeVal = $collectionSize->fetchColumn();
+            $permSizeVal = $permissionsSize->fetchColumn();
+            $size = (int) (\is_numeric($collSizeVal) ? $collSizeVal : 0) + (int) (\is_numeric($permSizeVal) ? $permSizeVal : 0);
         } catch (PDOException $e) {
-            throw $this->processException($e);
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
         }
+
+        return $size;
     }
 
     /**
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param string $relatedCollection
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @return bool
+     * Get Collection Size of the raw data
+     *
      * @throws DatabaseException
      */
-    public function createRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay = false,
-        string $id = '',
-        string $twoWayKey = ''
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
-        $id = $this->filter($id);
-        $twoWayKey = $this->filter($twoWayKey);
-        $sqlType = $this->getSQLType(Database::VAR_RELATIONSHIP, 0, false, false, false);
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                $sql = "ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL;";
+    public function getSizeOfCollection(string $collection): int
+    {
+        $collection = $this->filter($collection);
+        $collection = $this->getNamespace().'_'.$collection;
+        $database = $this->getDatabase();
+        $permissions = Storage::permissionsTable($collection);
+
+        $result = $this->createBuilder()
+            ->fromNone()
+            ->selectRaw(
+                'SUM(size) FROM (
+                    SELECT data_length + index_length AS size
+                    FROM INFORMATION_SCHEMA.TABLES
+                    WHERE table_name = ? AND
+                    table_schema = ?
+                    UNION ALL
+                    SELECT data_length + index_length AS size
+                    FROM INFORMATION_SCHEMA.TABLES
+                    WHERE table_name = ? AND
+                    table_schema = ?
+                ) AS sizes',
+                [$collection, $database, $permissions, $database]
+            )
+            ->build();
+
+        $statement = $this->executeResult($result, Event::CollectionRead);
 
-                if ($twoWay) {
-                    $sql .= "ALTER TABLE {$relatedTable} ADD COLUMN `{$twoWayKey}` {$sqlType} DEFAULT NULL;";
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                $sql = "ALTER TABLE {$relatedTable} ADD COLUMN `{$twoWayKey}` {$sqlType} DEFAULT NULL;";
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                $sql = "ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL;";
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                return true;
-            default:
-                throw new DatabaseException('Invalid relationship type');
+        try {
+            $this->execute($statement);
+            $size = $statement->fetchColumn();
+        } catch (PDOException $e) {
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
         }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        return (int) (\is_numeric($size) ? $size : 0);
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @param string|null $newKey
-     * @param string|null $newTwoWayKey
+     * Create a new attribute column, handling spatial types with MariaDB-specific syntax.
+     *
+     * @param string $collection The collection name
+     * @param Attribute $attribute The attribute definition
      * @return bool
+     *
      * @throws DatabaseException
      */
-    public function updateRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side,
-        ?string $newKey = null,
-        ?string $newTwoWayKey = null,
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
-
-        if (!\is_null($newKey)) {
-            $newKey = $this->filter($newKey);
-        }
-        if (!\is_null($newTwoWayKey)) {
-            $newTwoWayKey = $this->filter($newTwoWayKey);
-        }
-
-        $sql = '';
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($key !== $newKey) {
-                    $sql = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`;";
-                }
-                if ($twoWay && $twoWayKey !== $newTwoWayKey) {
-                    $sql .= "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`;";
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    if ($twoWayKey !== $newTwoWayKey) {
-                        $sql = "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`;";
-                    }
-                } else {
-                    if ($key !== $newKey) {
-                        $sql = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`;";
-                    }
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    if ($twoWayKey !== $newTwoWayKey) {
-                        $sql = "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`;";
-                    }
-                } else {
-                    if ($key !== $newKey) {
-                        $sql = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`;";
-                    }
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
-
-                $junction = $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence());
+    public function createAttribute(string $collection, Attribute $attribute): bool
+    {
+        if (\in_array($attribute->type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon])) {
+            $id = $this->filter($attribute->key);
+            $table = $this->getSQLTableRaw($collection);
+            $sqlType = $this->getSpatialSQLType($attribute->type->value, $attribute->required);
+            $sql = "ALTER TABLE {$table} ADD COLUMN {$this->quote($id)} {$sqlType}";
+            $lockType = $this->getLockType();
+            if (! empty($lockType)) {
+                $sql .= ' '.$lockType;
+            }
 
-                if (!\is_null($newKey)) {
-                    $sql = "ALTER TABLE {$junction} RENAME COLUMN `{$key}` TO `{$newKey}`;";
-                }
-                if ($twoWay && !\is_null($newTwoWayKey)) {
-                    $sql .= "ALTER TABLE {$junction} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`;";
-                }
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+            try {
+                $ok = $this->executeStatement($sql, Event::AttributeCreate);
+                $this->invalidateSpatialAttributesCache($collection);
 
-        if (empty($sql)) {
-            return true;
+                return $ok;
+            } catch (PDOException $e) {
+                throw $this->processException($e);
+            }
         }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        return parent::createAttribute($collection, $attribute);
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @return bool
+     * Update Attribute
+     *
      * @throws DatabaseException
      */
-    public function deleteRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side
-    ): bool {
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
+    {
         $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN `{$key}`;";
-                    if ($twoWay) {
-                        $sql .= "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`;";
-                    }
-                } elseif ($side === Database::RELATION_SIDE_CHILD) {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`;";
-                    if ($twoWay) {
-                        $sql .= "ALTER TABLE {$table} DROP COLUMN `{$key}`;";
-                    }
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`;";
-                } else {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN `{$key}`;";
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN `{$key}`;";
-                } else {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`;";
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
-
-                $junction = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence())
-                    : $this->getSQLTable('_' . $relatedCollection->getSequence() . '_' . $collection->getSequence());
-
-                $perms = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence() . '_perms')
-                    : $this->getSQLTable('_' . $relatedCollection->getSequence() . '_' . $collection->getSequence() . '_perms');
-
-                $sql = "DROP TABLE {$junction}; DROP TABLE {$perms}";
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+        $id = $this->filter($attribute->key);
+        $newKey = empty($newKey) ? null : $this->filter($newKey);
+        $sqlType = $this->getSQLType($attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        $schema = $this->createSchemaBuilder();
+        $tableRaw = $this->getSQLTableRaw($name);
 
-        if (empty($sql)) {
-            return true;
+        if (! empty($newKey)) {
+            $result = $schema->changeColumn($tableRaw, $id, $newKey, $sqlType);
+        } else {
+            $result = $schema->modifyColumn($tableRaw, $id, $sqlType);
         }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
-    }
-
-    /**
-     * Rename Index
-     *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
-     * @throws Exception
-     */
-    public function renameIndex(string $collection, string $old, string $new): bool
-    {
-        $collection = $this->filter($collection);
-        $old = $this->filter($old);
-        $new = $this->filter($new);
-
-        $sql = "ALTER TABLE {$this->getSQLTable($collection)} RENAME INDEX `{$old}` TO `{$new}`;";
+        $sql = $result->query;
 
-        $sql = $this->trigger(Database::EVENT_INDEX_RENAME, $sql);
+        try {
+            $ok = $this->executeStatement($sql, Event::AttributeUpdate);
+            $this->invalidateSpatialAttributesCache($collection);
 
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+            return $ok;
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
     }
 
     /**
      * Create Index
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param array<string,string> $indexAttributeTypes
-     * @return bool
+     * @param  array<string,string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
+     *
      * @throws DatabaseException
      */
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
-        $metadataCollection = new Document(['$id' => Database::METADATA]);
+        $metadataCollection = new Document([Document::ID => Database::METADATA]);
         $collection = $this->getDocument($metadataCollection, $collection);
 
         if ($collection->isEmpty()) {
             throw new NotFoundException('Collection not found');
         }
 
-        /**
-         * We do not have sequence's added to list, since we check only for array field
-         */
-        $collectionAttributes = \json_decode($collection->getAttribute('attributes', []), true);
+        $rawAttrs = $collection->getAttribute('attributes', []);
+        /** @var array<int, array<string, mixed>> $collectionAttributes */
+        $collectionAttributes = \is_string($rawAttrs) ? (\json_decode($rawAttrs, true) ?? []) : [];
+        $id = $this->filter($index->key);
+        $type = $index->type;
+        $attributes = $index->attributes;
+        $lengths = $index->lengths;
+        $orders = $index->orders;
 
-        $id = $this->filter($id);
+        $schema = $this->createSchemaBuilder();
+        $tableName = $this->getSQLTableRaw($collection->getId());
+
+        // Build column lists, separating regular columns from raw CAST ARRAY expressions
+        $schemaColumns = [];
+        $schemaLengths = [];
+        $schemaOrders = [];
+        $rawExpressions = [];
 
         foreach ($attributes as $i => $attr) {
             $attribute = null;
             foreach ($collectionAttributes as $collectionAttribute) {
-                if (\strtolower($collectionAttribute['$id']) === \strtolower($attr)) {
+                $collAttrId = $collectionAttribute[Document::ID] ?? '';
+                if (\strtolower(\is_string($collAttrId) ? $collAttrId : '') === \strtolower($attr)) {
                     $attribute = $collectionAttribute;
                     break;
                 }
             }
 
-            $order = empty($orders[$i]) || Database::INDEX_FULLTEXT === $type ? '' : $orders[$i];
-            $length = empty($lengths[$i]) ? '' : '(' . (int)$lengths[$i] . ')';
-
-            $attr = $this->getInternalKeyForAttribute($attr);
-            $attr = $this->filter($attr);
-
-            $attributes[$i] = "`{$attr}`{$length} {$order}";
+            $attr = $this->filter($this->getInternalKeyForAttribute($attr));
+            $order = $type === IndexType::Fulltext ? '' : Index::direction($orders[$i] ?? null);
+            $length = empty($lengths[$i]) ? 0 : (int) $lengths[$i];
 
-            if ($this->getSupportForCastIndexArray() && !empty($attribute['array'])) {
-                $attributes[$i] = '(CAST(`' . $attr . '` AS char(' . Database::MAX_ARRAY_INDEX_LENGTH . ') ARRAY))';
+            if ($this->supports(Capability::CastIndexArray) && ! empty($attribute['array'])) {
+                $rawExpressions[] = '(CAST(`'.$attr.'` AS char('.Database::MAX_ARRAY_INDEX_LENGTH.') ARRAY))';
+            } else {
+                $schemaColumns[] = $attr;
+                if ($length > 0) {
+                    $schemaLengths[$attr] = $length;
+                }
+                if (! empty($order)) {
+                    $schemaOrders[$attr] = $order;
+                }
             }
         }
 
-        $sqlType = match ($type) {
-            Database::INDEX_KEY => 'INDEX',
-            Database::INDEX_UNIQUE => 'UNIQUE INDEX',
-            Database::INDEX_FULLTEXT => 'FULLTEXT INDEX',
-            Database::INDEX_SPATIAL => 'SPATIAL INDEX',
-            default => throw new DatabaseException('Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT . ', ' . Database::INDEX_SPATIAL),
-        };
-
-        $attributes = \implode(', ', $attributes);
-
-        if ($this->sharedTables && $type !== Database::INDEX_FULLTEXT && $type !== Database::INDEX_SPATIAL) {
-            // Add tenant as first index column for best performance
-            $attributes = "_tenant, {$attributes}";
+        if ($this->sharedTables && $type !== IndexType::Fulltext && $type !== IndexType::Spatial) {
+            \array_unshift($schemaColumns, Storage::TENANT);
         }
 
-        $sql =  "CREATE {$sqlType} `{$id}` ON {$this->getSQLTable($collection->getId())} ({$attributes})";
-        $sql = $this->trigger(Database::EVENT_INDEX_CREATE, $sql);
+        $unique = $type === IndexType::Unique;
+        $schemaType = match ($type) {
+            IndexType::Key, IndexType::Unique => '',
+            IndexType::Fulltext => 'fulltext',
+            IndexType::Spatial => 'spatial',
+            default => throw new DatabaseException('Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value.', '.IndexType::Spatial->value),
+        };
+
+        $result = $schema->createIndex(
+            $tableName,
+            $id,
+            $schemaColumns,
+            unique: $unique,
+            type: $schemaType,
+            lengths: $schemaLengths,
+            orders: $schemaOrders,
+            rawColumns: $rawExpressions,
+        );
+        $sql = $result->query;
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            return $this->executeStatement($sql, Event::IndexCreate);
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -786,9 +560,6 @@ public function createIndex(string $collection, string $id, string $type, array
     /**
      * Delete Index
      *
-     * @param string $collection
-     * @param string $id
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
@@ -797,16 +568,15 @@ public function deleteIndex(string $collection, string $id): bool
         $name = $this->filter($collection);
         $id = $this->filter($id);
 
-        $sql = "ALTER TABLE {$this->getSQLTable($name)} DROP INDEX `{$id}`;";
+        $schema = $this->createSchemaBuilder();
+        $result = $schema->dropIndex($this->getSQLTableRaw($name), $id);
 
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
+        $sql = $result->query;
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            return $this->executeStatement($sql, Event::IndexDelete);
         } catch (PDOException $e) {
-            if ($e->getCode() === "42000" && $e->errorInfo[1] === 1091) {
+            if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1091) {
                 return true;
             }
 
@@ -814,12 +584,26 @@ public function deleteIndex(string $collection, string $id): bool
         }
     }
 
+    /**
+     * Rename Index
+     *
+     * @throws Exception
+     */
+    public function renameIndex(string $collection, string $old, string $new): bool
+    {
+        $collection = $this->filter($collection);
+        $old = $this->filter($old);
+        $new = $this->filter($new);
+
+        $result = $this->createSchemaBuilder()->renameIndex($this->getSQLTableRaw($collection), $old, $new);
+        $sql = $result->query;
+
+        return $this->executeStatement($sql, Event::IndexRename);
+    }
+
     /**
      * Create Document
      *
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
      * @throws Exception
      * @throws PDOException
      * @throws DuplicateException
@@ -828,130 +612,83 @@ public function deleteIndex(string $collection, string $id): bool
     public function createDocument(Document $collection, Document $document): Document
     {
         try {
+            $this->syncWriteHooks();
+
             $spatialAttributes = $this->getSpatialAttributes($collection);
             $collection = $collection->getId();
             $attributes = $document->getAttributes();
-            $attributes['_createdAt'] = $document->getCreatedAt();
-            $attributes['_updatedAt'] = $document->getUpdatedAt();
-            $attributes['_permissions'] = \json_encode($document->getPermissions());
-
-            if ($this->sharedTables) {
-                $attributes['_tenant'] = $document->getTenant();
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = \json_encode($document->getPermissions());
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
             }
 
             $name = $this->filter($collection);
-            $columns = '';
-            $columnNames = '';
 
-            /**
-             * Insert Attributes
-             */
-            $bindIndex = 0;
-            foreach ($attributes as $attribute => $value) {
-                $column = $this->filter($attribute);
-                $bindKey = 'key_' . $bindIndex;
-                $columns .= "`{$column}`, ";
-                if (in_array($attribute, $spatialAttributes)) {
-                    $columnNames .= $this->getSpatialGeomFromText(':' . $bindKey) . ", ";
-                } else {
-                    $columnNames .= ':' . $bindKey . ', ';
-                }
-                $bindIndex++;
-            }
-
-            // Insert internal ID if set
-            if (!empty($document->getSequence())) {
-                $bindKey = '_id';
-                $columns .= "_id, ";
-                $columnNames .= ':' . $bindKey . ', ';
-            }
-
-            $sql = "
-			    INSERT INTO {$this->getSQLTable($name)} ({$columns} _uid)
-			    VALUES ({$columnNames} :_uid)
-			";
-
-            $sql = $this->trigger(Database::EVENT_DOCUMENT_CREATE, $sql);
+            // Build document INSERT using query builder
+            // Spatial columns use insertColumnExpression() for ST_GeomFromText() wrapping
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+            $row = [Storage::UID => $document->getId()];
 
-            $stmt = $this->getPDO()->prepare($sql);
-
-            $stmt->bindValue(':_uid', $document->getId());
-
-            if (!empty($document->getSequence())) {
-                $stmt->bindValue(':_id', $document->getSequence());
+            if (! empty($document->getSequence())) {
+                $row[Storage::SEQUENCE] = $document->getSequence();
             }
 
-            $attributeIndex = 0;
-            foreach ($attributes as $value) {
-                if (\is_array($value)) {
-                    $value = \json_encode($value);
-                }
+            $spatialMap = \array_fill_keys($spatialAttributes, true);
 
-                $bindKey = 'key_' . $attributeIndex;
-                $attribute = $this->filter($attribute);
-                $value = (\is_bool($value)) ? (int)$value : $value;
-                $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                $attributeIndex++;
-            }
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
 
-            $permissions = [];
-            foreach (Database::PERMISSIONS as $type) {
-                foreach ($document->getPermissionsByType($type) as $permission) {
-                    $tenantBind = $this->sharedTables ? ", :_tenant" : '';
-                    $permission = \str_replace('"', '', $permission);
-                    $permission = "('{$type}', '{$permission}', :_uid {$tenantBind})";
-                    $permissions[] = $permission;
+                if (isset($spatialMap[$attr]) || $this->isSpatialWkt($value)) {
+                    $value = $this->encodeSpatialWriteValue($value);
+                    $value = (\is_bool($value)) ? (int) $value : $value;
+                    $row[$column] = $value;
+                    $builder->insertColumnExpression($column, $this->getSpatialGeomFromText('?'));
+                } else {
+                    if (\is_array($value)) {
+                        $value = \json_encode($value);
+                    }
+                    $value = (\is_bool($value)) ? (int) $value : $value;
+                    $row[$column] = $value;
                 }
             }
 
-            if (!empty($permissions)) {
-                $tenantColumn = $this->sharedTables ? ', _tenant' : '';
-                $permissions = \implode(', ', $permissions);
-
-                $sqlPermissions = "
-                    INSERT INTO {$this->getSQLTable($name . '_perms')} (_type, _permission, _document {$tenantColumn})
-                    VALUES {$permissions};
-                ";
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
 
-                $stmtPermissions = $this->getPDO()->prepare($sqlPermissions);
-                $stmtPermissions->bindValue(':_uid', $document->getId());
-                if ($this->sharedTables) {
-                    $stmtPermissions->bindValue(':_tenant', $document->getTenant());
-                }
-            }
+            $this->execute($stmt);
 
-            $stmt->execute();
+            $document[Document::SEQUENCE] = $this->getPDO()->lastInsertId();
 
-            $document['$sequence'] = $this->pdo->lastInsertId();
-
-            if (empty($document['$sequence'])) {
-                throw new DatabaseException('Error creating document empty "$sequence"');
+            if (empty($document[Document::SEQUENCE])) {
+                throw new DatabaseException('Error creating document empty "'.Document::SEQUENCE.'"');
             }
 
-            if (isset($stmtPermissions)) {
-                try {
-                    $stmtPermissions->execute();
-                } catch (PDOException $e) {
-                    $isOrphanedPermission = $e->getCode() === '23000'
-                        && isset($e->errorInfo[1])
-                        && $e->errorInfo[1] === 1062
-                        && \str_contains($e->getMessage(), '_index1');
-
-                    if (!$isOrphanedPermission) {
-                        throw $e;
-                    }
+            $ctx = $this->buildWriteContext($name);
+            try {
+                $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, [$document], $ctx));
+            } catch (PDOException $e) {
+                $isOrphanedPermission = $e->getCode() === '23000'
+                    && isset($e->errorInfo[1])
+                    && $e->errorInfo[1] === 1062
+                    && \str_contains($e->getMessage(), Storage::INDEX_1);
+
+                if (! $isOrphanedPermission) {
+                    throw $e;
+                }
 
-                    // Clean up orphaned permissions from a previous failed delete, then retry
-                    $sql = "DELETE FROM {$this->getSQLTable($name . '_perms')} WHERE _document = :_uid {$this->getTenantQuery($collection)}";
-                    $cleanup = $this->getPDO()->prepare($sql);
-                    $cleanup->bindValue(':_uid', $document->getId());
-                    if ($this->sharedTables) {
-                        $cleanup->bindValue(':_tenant', $document->getTenant());
-                    }
-                    $cleanup->execute();
+                // Clean up orphaned permissions from a previous failed delete, then retry
+                $cleanupBuilder = $this->newBuilder(Storage::permissionsTable($name));
+                $cleanupBuilder->filter([BaseQuery::equal(Storage::PERM_DOCUMENT, [$document->getId()])]);
+                $cleanupResult = $cleanupBuilder->delete();
+                $cleanupStmt = $this->executeResult($cleanupResult, Event::PermissionsDelete);
+                $this->execute($cleanupStmt);
 
-                    $stmtPermissions->execute();
-                }
+                $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, [$document], $ctx));
             }
         } catch (PDOException $e) {
             throw $this->processException($e);
@@ -963,11 +700,6 @@ public function createDocument(Document $collection, Document $document): Docume
     /**
      * Update Document
      *
-     * @param Document $collection
-     * @param string $id
-     * @param Document $document
-     * @param bool $skipPermissions
-     * @return Document
      * @throws Exception
      * @throws PDOException
      * @throws DuplicateException
@@ -976,142 +708,68 @@ public function createDocument(Document $collection, Document $document): Docume
     public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
         try {
+            $this->syncWriteHooks();
+
             $spatialAttributes = $this->getSpatialAttributes($collection);
             $collection = $collection->getId();
             $attributes = $document->getAttributes();
-            $attributes['_createdAt'] = $document->getCreatedAt();
-            $attributes['_updatedAt'] = $document->getUpdatedAt();
-            $attributes['_permissions'] = json_encode($document->getPermissions());
-            $attributes['_uid'] = $document->getId();
-
-            $name = $this->filter($collection);
-            $columns = '';
-
-            if (!$skipPermissions) {
-                $newUid = $document->offsetExists('$id') ? $document->getId() : $id;
-
-                $sql = "
-			    DELETE FROM {$this->getSQLTable($name . '_perms')}
-			    WHERE _document = :_uid
-			    {$this->getTenantQuery($collection)}
-			    ";
-
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
-
-                $stmtRemovePermissions = $this->getPDO()->prepare($sql);
-                $stmtRemovePermissions->bindValue(':_uid', $id);
-                if ($this->sharedTables) {
-                    $stmtRemovePermissions->bindValue(':_tenant', $document->getTenant());
-                }
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = json_encode($document->getPermissions());
 
-                $values = [];
-                $binds = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    foreach ($document->getPermissionsByType($type) as $i => $permission) {
-                        $tenantPlaceholder = $this->sharedTables ? ', :_tenant' : '';
-                        $values[] = "( :_uid, '{$type}', :_add_{$type}_{$i} {$tenantPlaceholder})";
-                        $binds[":_add_{$type}_{$i}"] = $permission;
-                    }
-                }
-
-                if (!empty($values)) {
-                    $tenantColumn = $this->sharedTables ? ', _tenant' : '';
-
-                    $sql = "
-				    INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission {$tenantColumn})
-				    VALUES " . \implode(', ', $values);
-
-                    $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
-
-                    $stmtAddPermissions = $this->getPDO()->prepare($sql);
-                    $stmtAddPermissions->bindValue(":_uid", $newUid);
-                    if ($this->sharedTables) {
-                        $stmtAddPermissions->bindValue(":_tenant", $document->getTenant());
-                    }
-
-                    foreach ($binds as $key => $permission) {
-                        $stmtAddPermissions->bindValue($key, $permission);
-                    }
-                }
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
             }
 
-            /**
-             * Update Attributes
-             */
-            $keyIndex = 0;
-            $operatorBinds = [];
+            $name = $this->filter($collection);
 
+            $operators = [];
             foreach ($attributes as $attribute => $value) {
-                $column = $this->filter($attribute);
-
-                // Check if this is an operator or regular attribute
                 if (Operator::isOperator($value)) {
-                    $operatorSQL = $this->getOperatorSQL($column, $value, $operatorBinds);
-                    $columns .= $operatorSQL . ',';
-                } else {
-                    $bindKey = 'key_' . $keyIndex;
-
-                    if (in_array($attribute, $spatialAttributes)) {
-                        $columns .= "`{$column}`" . '=' . $this->getSpatialGeomFromText(':' . $bindKey) . ',';
-                    } else {
-                        $columns .= "`{$column}`" . '=:' . $bindKey . ',';
-                    }
-                    $keyIndex++;
+                    $operators[$attribute] = $value;
                 }
             }
 
-            $sql = "
-                UPDATE {$this->getSQLTable($name)}
-                SET " . \rtrim($columns, ',') . "
-                WHERE _id=:_sequence
-                {$this->getTenantQuery($collection)}
-			";
-
-            $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-            $stmt = $this->getPDO()->prepare($sql);
-
-            $stmt->bindValue(':_sequence', $document->getSequence());
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
+            $builder = $this->newBuilder($name);
+            $regularRow = [];
+            if (\strcasecmp($document->getId(), $id) !== 0) {
+                $regularRow[Storage::UID] = $document->getId();
             }
 
-            $keyIndex = 0;
+            $spatialMap = \array_fill_keys($spatialAttributes, true);
+
             foreach ($attributes as $attribute => $value) {
-                // Handle operators separately
-                if (Operator::isOperator($value)) {
-                    continue;
-                }
+                $column = $this->filter($attribute);
 
-                // Convert spatial arrays to WKT, json_encode non-spatial arrays
-                if (\in_array($attribute, $spatialAttributes, true)) {
+                if (isset($operators[$attribute])) {
+                    $op = $operators[$attribute];
+                    if ($op instanceof Operator) {
+                        $opResult = $this->getOperatorBuilderExpression($column, $op);
+                        $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
+                    }
+                } elseif (isset($spatialMap[$attribute]) || $this->isSpatialWkt($value)) {
+                    $value = $this->encodeSpatialWriteValue($value);
+                    $value = (\is_bool($value)) ? (int) $value : $value;
+                    $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$value]);
+                } else {
                     if (\is_array($value)) {
-                        $value = $this->convertArrayToWKT($value);
+                        $value = \json_encode($value);
                     }
-                } elseif (is_array($value)) {
-                    $value = json_encode($value);
+                    $value = (\is_bool($value)) ? (int) $value : $value;
+                    $regularRow[$column] = $value;
                 }
-
-                $bindKey = 'key_' . $keyIndex;
-                $value = (is_bool($value)) ? (int)$value : $value;
-                $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                $keyIndex++;
-            }
-
-            foreach ($operatorBinds as $bindKey => $bindValue) {
-                $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
             }
 
-            $stmt->execute();
+            $builder->set($regularRow);
+            $builder->filter([BaseQuery::equal(Storage::SEQUENCE, [$document->getSequence()])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-            if (isset($stmtRemovePermissions)) {
-                $stmtRemovePermissions->execute();
-            }
-            if (isset($stmtAddPermissions)) {
-                $stmtAddPermissions->execute();
-            }
+            $this->execute($stmt);
 
+            $ctx = $this->buildWriteContext($name, $id);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpdate($name, $document, $skipPermissions, $ctx));
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -1120,585 +778,423 @@ public function updateDocument(Document $collection, string $id, Document $docum
     }
 
     /**
-     * @param string $tableName
-     * @param string $columns
-     * @param array<string> $batchKeys
-     * @param array<string> $attributes
-     * @param array<mixed> $bindValues
-     * @param string $attribute
-     * @param array<Operator> $operators
-     * @return mixed
+     * Set max execution time
+     *
      * @throws DatabaseException
      */
-    public function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = []
-    ): mixed {
-        $getUpdateClause = function (string $attribute, bool $increment = false): string {
-            $attribute = $this->quote($this->filter($attribute));
-
-            if ($increment) {
-                $new = "{$attribute} + VALUES({$attribute})";
-            } else {
-                $new = "VALUES({$attribute})";
-            }
-
-            if ($this->sharedTables) {
-                return "{$attribute} = IF(_tenant = VALUES(_tenant), {$new}, {$attribute})";
-            }
-
-            return "{$attribute} = {$new}";
-        };
-
-        $updateColumns = [];
-        $operatorBinds = [];
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
+    {
+        if ($milliseconds <= 0) {
+            throw new DatabaseException('Timeout must be greater than 0');
+        }
 
-        if (!empty($attribute)) {
-            // Increment specific column by its new value in place
-            $updateColumns = [
-                $getUpdateClause($attribute, increment: true),
-                $getUpdateClause('_updatedAt'),
-            ];
-        } else {
-            foreach (\array_keys($attributes) as $attr) {
-                /**
-                 * @var string $attr
-                 */
-                $filteredAttr = $this->filter($attr);
-
-                if (isset($operators[$attr])) {
-                    $operatorSQL = $this->getOperatorSQL($filteredAttr, $operators[$attr], $operatorBinds);
-                    if ($operatorSQL !== null) {
-                        $updateColumns[] = $operatorSQL;
-                    }
-                } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
-                        $updateColumns[] = $getUpdateClause($filteredAttr);
-                    }
-                }
-            }
+        if ($event === Event::All) {
+            $this->applyTimeout($milliseconds);
         }
 
-        $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} {$columns}
-            VALUES " . \implode(', ', $batchKeys) . "
-            ON DUPLICATE KEY UPDATE
-                " . \implode(', ', $updateColumns)
-        );
+        $this->setTimeoutState($milliseconds, $event);
+    }
 
-        foreach ($bindValues as $key => $binding) {
-            $stmt->bindValue($key, $binding, $this->getPDOType($binding));
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        if ($event === Event::All) {
+            $this->applyTimeout(0);
         }
 
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
-        }
+        $this->clearTimeoutState($event);
+    }
 
-        return $stmt;
+    /**
+     * Size of POINT spatial type
+     */
+    protected function getMaxPointSize(): int
+    {
+        // https://dev.mysql.com/doc/refman/8.4/en/gis-data-formats.html#gis-internal-format
+        return 25;
     }
 
     /**
-     * Increase or decrease an attribute value
+     * Decode a WKB or WKT POINT into a coordinate array [x, y].
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $attribute
-     * @param int|float $value
-     * @param string $updatedAt
-     * @param int|float|null $min
-     * @param int|float|null $max
-     * @return bool
-     * @throws DatabaseException
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<float>
+     *
+     * @throws DatabaseException If the input is invalid.
      */
-    public function increaseDocumentAttribute(
-        string $collection,
-        string $id,
-        string $attribute,
-        int|float $value,
-        string $updatedAt,
-        int|float|null $min = null,
-        int|float|null $max = null
-    ): bool {
-        $name = $this->filter($collection);
-        $attribute = $this->filter($attribute);
-
-        $sqlMax = $max !== null ? " AND `{$attribute}` <= :max" : '';
-        $sqlMin = $min !== null ? " AND `{$attribute}` >= :min" : '';
-
-        $sql = "
-			UPDATE {$this->getSQLTable($name)}
-			SET
-			    `{$attribute}` = `{$attribute}` + :val,
-			    `_updatedAt` = :updatedAt
-			WHERE _uid = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+    #[\Override]
+    public function decodePoint(string $wkb): array
+    {
+        if (str_starts_with(strtoupper($wkb), 'POINT(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, $end - $start);
+            $coords = explode(' ', trim($inside));
 
-        $sql .= $sqlMax . $sqlMin;
+            return [(float) $coords[0], (float) $coords[1]];
+        }
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
+        /**
+         * [0..3]   SRID (4 bytes, little-endian)
+         * [4]      Byte order (1 = little-endian, 0 = big-endian)
+         * [5..8]   Geometry type (with SRID flag bit)
+         * [9..]    Geometry payload (coordinates, etc.)
+         */
+        if (strlen($wkb) < 25) {
+            throw new DatabaseException('Invalid WKB: too short for POINT');
+        }
 
-        $stmt = $this->getPDO()->prepare($sql);
-        $stmt->bindValue(':_uid', $id);
-        $stmt->bindValue(':val', $value);
-        $stmt->bindValue(':updatedAt', $updatedAt);
+        // 4 bytes SRID first → skip to byteOrder at offset 4
+        $byteOrder = ord($wkb[4]);
+        $littleEndian = ($byteOrder === 1);
 
-        if ($max !== null) {
-            $stmt->bindValue(':max', $max);
-        }
-        if ($min !== null) {
-            $stmt->bindValue(':min', $min);
+        if (! $littleEndian) {
+            throw new DatabaseException('Only little-endian WKB supported');
         }
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+
+        // After SRID (4) + byteOrder (1) + type (4) = 9 bytes
+        $coordsBin = substr($wkb, 9, 16);
+        if (strlen($coordsBin) !== 16) {
+            throw new DatabaseException('Invalid WKB: missing coordinate bytes');
         }
 
-        try {
-            $stmt->execute();
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        // Unpack two doubles
+        $coords = unpack('d2', $coordsBin);
+        if ($coords === false || ! isset($coords[1], $coords[2])) {
+            throw new DatabaseException('Invalid WKB: failed to unpack coordinates');
         }
 
-        return true;
+        return [(float) (is_numeric($coords[1]) ? $coords[1] : 0), (float) (is_numeric($coords[2]) ? $coords[2] : 0)];
     }
 
     /**
-     * Delete Document
+     * Decode a WKB or WKT LINESTRING into an array of coordinate pairs.
      *
-     * @param string $collection
-     * @param string $id
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<array<float>>
+     *
+     * @throws DatabaseException If the input is invalid.
      */
-    public function deleteDocument(string $collection, string $id): bool
+    #[\Override]
+    public function decodeLinestring(string $wkb): array
     {
-        try {
-            $name = $this->filter($collection);
-
-            $sql = "
-                DELETE FROM {$this->getSQLTable($name)} 
-                WHERE _uid = :_uid
-                {$this->getTenantQuery($collection)}
-		    ";
+        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, $end - $start);
 
-            $sql = $this->trigger(Database::EVENT_DOCUMENT_DELETE, $sql);
+            $points = explode(',', $inside);
 
-            $stmt = $this->getPDO()->prepare($sql);
+            return array_map(function ($point) {
+                $coords = explode(' ', trim($point));
 
-            $stmt->bindValue(':_uid', $id);
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
-            }
+                return [(float) $coords[0], (float) $coords[1]];
+            }, $points);
+        }
 
-            $sql = "
-			    DELETE FROM {$this->getSQLTable($name . '_perms')} 
-		        WHERE _document = :_uid
-		        {$this->getTenantQuery($collection)}
-		    ";
+        // Skip 1 byte (endianness) + 4 bytes (type) + 4 bytes (SRID)
+        $offset = 9;
 
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
+        // Number of points (4 bytes little-endian)
+        $numPointsArr = unpack('V', substr($wkb, $offset, 4));
+        if ($numPointsArr === false || ! isset($numPointsArr[1])) {
+            throw new DatabaseException('Invalid WKB: cannot unpack number of points');
+        }
 
-            $stmtPermissions = $this->getPDO()->prepare($sql);
-            $stmtPermissions->bindValue(':_uid', $id);
+        $numPoints = $numPointsArr[1];
+        $offset += 4;
 
-            if ($this->sharedTables) {
-                $stmtPermissions->bindValue(':_tenant', $this->tenant);
-            }
+        $points = [];
+        for ($i = 0; $i < $numPoints; $i++) {
+            $xArr = unpack('d', substr($wkb, $offset, 8));
+            $yArr = unpack('d', substr($wkb, $offset + 8, 8));
 
-            if (!$stmt->execute()) {
-                throw new DatabaseException('Failed to delete document');
+            if ($xArr === false || ! isset($xArr[1]) || $yArr === false || ! isset($yArr[1])) {
+                throw new DatabaseException('Invalid WKB: cannot unpack point coordinates');
             }
 
-            $deleted = $stmt->rowCount();
-
-            if (!$stmtPermissions->execute()) {
-                throw new DatabaseException('Failed to delete permissions');
-            }
-        } catch (\Throwable $e) {
-            throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+            $points[] = [(float) (is_numeric($xArr[1]) ? $xArr[1] : 0), (float) (is_numeric($yArr[1]) ? $yArr[1] : 0)];
+            $offset += 16;
         }
 
-        return $deleted;
+        return $points;
     }
 
     /**
-     * Handle distance spatial queries
+     * Decode a WKB or WKT POLYGON into an array of rings, each containing coordinate pairs.
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $type
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
-    */
-    protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
-    {
-        $distanceParams = $query->getValues()[0];
-        $wkt = $this->convertArrayToWKT($distanceParams[0]);
-        $binds[":{$placeholder}_0"] = $wkt;
-        $binds[":{$placeholder}_1"] = $distanceParams[1];
-
-        $useMeters = isset($distanceParams[2]) && $distanceParams[2] === true;
-
-        switch ($query->getMethod()) {
-            case Query::TYPE_DISTANCE_EQUAL:
-                $operator = '=';
-                break;
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-                $operator = '!=';
-                break;
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-                $operator = '>';
-                break;
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                $operator = '<';
-                break;
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
-        }
-
-        if ($useMeters) {
-            $wktType = $this->getSpatialTypeFromWKT($wkt);
-            $attrType = strtolower($type);
-            if ($wktType != Database::VAR_POINT || $attrType != Database::VAR_POINT) {
-                throw new QueryException('Distance in meters is not supported between '.$attrType . ' and '. $wktType);
-            }
-            return "ST_DISTANCE_SPHERE({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ", " . Database::EARTH_RADIUS . ") {$operator} :{$placeholder}_1";
-        }
-        return "ST_Distance({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ") {$operator} :{$placeholder}_1";
-    }
-
-    /**
-     * Handle spatial queries
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<array<array<float>>>
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $type
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
+     * @throws DatabaseException If the input is invalid.
      */
-    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
+    #[\Override]
+    public function decodePolygon(string $wkb): array
     {
-        switch ($query->getMethod()) {
-            case Query::TYPE_CROSSES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Crosses({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        // POLYGON((x1,y1),(x2,y2))
+        if (str_starts_with($wkb, 'POLYGON((')) {
+            $start = strpos($wkb, '((') + 2;
+            $end = strrpos($wkb, '))');
+            $inside = substr($wkb, $start, $end - $start);
 
-            case Query::TYPE_NOT_CROSSES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Crosses({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+            $rings = explode('),(', $inside);
 
-            case Query::TYPE_DISTANCE_EQUAL:
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                return $this->handleDistanceSpatialQueries($query, $binds, $attribute, $type, $alias, $placeholder);
+            return array_map(function ($ring) {
+                $points = explode(',', $ring);
 
-            case Query::TYPE_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+                return array_map(function ($point) {
+                    $coords = explode(' ', trim($point));
 
-            case Query::TYPE_NOT_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+                    return [(float) $coords[0], (float) $coords[1]];
+                }, $points);
+            }, $rings);
+        }
 
-            case Query::TYPE_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        // Convert HEX string to binary if needed
+        if (str_starts_with($wkb, '0x') || ctype_xdigit($wkb)) {
+            $wkb = hex2bin(str_starts_with($wkb, '0x') ? substr($wkb, 2) : $wkb);
+            if ($wkb === false) {
+                throw new DatabaseException('Invalid hex WKB');
+            }
+        }
 
-            case Query::TYPE_NOT_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        if (strlen($wkb) < 21) {
+            throw new DatabaseException('WKB too short to be a POLYGON');
+        }
 
-            case Query::TYPE_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        // MySQL SRID-aware WKB layout: 4 bytes SRID prefix
+        $offset = 4;
 
-            case Query::TYPE_NOT_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        $byteOrder = ord($wkb[$offset]);
+        if ($byteOrder !== 1) {
+            throw new DatabaseException('Only little-endian WKB supported');
+        }
+        $offset += 1;
 
-            case Query::TYPE_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        $typeArr = unpack('V', substr($wkb, $offset, 4));
+        if ($typeArr === false || ! isset($typeArr[1])) {
+            throw new DatabaseException('Invalid WKB: cannot unpack geometry type');
+        }
 
-            case Query::TYPE_NOT_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        $type = \is_numeric($typeArr[1]) ? (int) $typeArr[1] : 0;
+        $hasSRID = ($type & 0x20000000) === 0x20000000;
+        $geomType = $type & 0xFF;
+        $offset += 4;
 
-            case Query::TYPE_CONTAINS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Contains({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        if ($geomType !== 3) { // 3 = POLYGON
+            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
+        }
 
-            case Query::TYPE_NOT_CONTAINS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Contains({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
+        // Skip SRID in type flag if present
+        if ($hasSRID) {
+            $offset += 4;
+        }
 
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
-                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
+        $numRingsArr = unpack('V', substr($wkb, $offset, 4));
 
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
+        if ($numRingsArr === false || ! isset($numRingsArr[1])) {
+            throw new DatabaseException('Invalid WKB: cannot unpack number of rings');
         }
-    }
-
-    /**
-     * Get SQL Condition
-     *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLCondition(Query $query, array &$binds, ?string $forCollection = null): string
-    {
-        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        $attribute = $query->getAttribute();
-        $attribute = $this->filter($attribute);
-        $attribute = $this->quote($attribute);
-        $alias = $this->quote(Query::DEFAULT_ALIAS);
-        $placeholder = ID::unique();
+        $numRings = $numRingsArr[1];
+        $offset += 4;
 
-        if ($query->isSpatialAttribute()) {
-            return $this->handleSpatialQueries($query, $binds, $attribute, $query->getAttributeType(), $alias, $placeholder);
-        }
+        $rings = [];
 
-        switch ($query->getMethod()) {
-            case Query::TYPE_OR:
-            case Query::TYPE_AND:
-                $conditions = [];
-                /* @var $q Query */
-                foreach ($query->getValue() as $q) {
-                    $conditions[] = $this->getSQLCondition($q, $binds, $forCollection);
-                }
+        for ($r = 0; $r < $numRings; $r++) {
+            $numPointsArr = unpack('V', substr($wkb, $offset, 4));
 
-                $method = strtoupper($query->getMethod());
+            if ($numPointsArr === false || ! isset($numPointsArr[1])) {
+                throw new DatabaseException('Invalid WKB: cannot unpack number of points');
+            }
 
-                return empty($conditions) ? '' : ' '. $method .' (' . implode(' AND ', $conditions) . ')';
+            $numPoints = $numPointsArr[1];
+            $offset += 4;
+            $ring = [];
 
-            case Query::TYPE_SEARCH:
-                $fulltextValue = $this->getFulltextValue($query->getValue());
-                if ($fulltextValue === '') {
-                    return '0 = 1';
+            for ($p = 0; $p < $numPoints; $p++) {
+                $xArr = unpack('d', substr($wkb, $offset, 8));
+                if ($xArr === false) {
+                    throw new DatabaseException('Failed to unpack X coordinate from WKB.');
                 }
-                $binds[":{$placeholder}_0"] = $fulltextValue;
 
-                return "MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE)";
+                $x = (float) (is_numeric($xArr[1]) ? $xArr[1] : 0);
 
-            case Query::TYPE_NOT_SEARCH:
-                $fulltextValue = $this->getFulltextValue($query->getValue());
-                if ($fulltextValue === '') {
-                    return '1 = 1';
+                $yArr = unpack('d', substr($wkb, $offset + 8, 8));
+                if ($yArr === false) {
+                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
                 }
-                $binds[":{$placeholder}_0"] = $fulltextValue;
-
-                return "NOT (MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE))";
 
-            case Query::TYPE_BETWEEN:
-                $binds[":{$placeholder}_0"] = $query->getValues()[0];
-                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+                $y = (float) (is_numeric($yArr[1]) ? $yArr[1] : 0);
 
-                return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+                $ring[] = [$x, $y];
+                $offset += 16;
+            }
 
-            case Query::TYPE_NOT_BETWEEN:
-                $binds[":{$placeholder}_0"] = $query->getValues()[0];
-                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+            $rings[] = $ring;
+        }
 
-                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+        return $rings;
+    }
 
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
+    /** Last value pushed to MariaDB session var max_statement_time, in seconds. */
+    private float $appliedMaxStatementTime = 0.0;
 
-                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
-            case Query::TYPE_CONTAINS_ALL:
-                if ($query->onArray()) {
-                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
-                    return "JSON_CONTAINS({$alias}.{$attribute}, :{$placeholder}_0)";
-                }
-                // no break
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
-            case Query::TYPE_NOT_CONTAINS:
-                if ($query->onArray()) {
-                    $isNot = $query->getMethod() === Query::TYPE_NOT_CONTAINS;
-
-                    if ($this->getSupportForJSONOverlaps()) {
-                        $binds[":{$placeholder}_0"] = json_encode($query->getValues());
-                        return $isNot
-                            ? "NOT (JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0))"
-                            : "JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0)";
-                    }
+    /**
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
+     */
+    protected function execute(mixed $stmt, ?Event $event = null): bool
+    {
+        $event ??= $this->getStatementEvent($stmt);
+        $baseline = $this->getTimeout();
+        $timeout = $event === null ? $baseline : $this->getTimeout($event);
+        $this->applyTimeout($timeout);
 
-                    // JSON_CONTAINS per element OR'd together — exact
-                    // element match without LIKE's substring false positives
-                    // (`%2%` matching `[12, 200]`, `%"apple"%` matching
-                    // `["pineapple"]`).
-                    $conditions = [];
-                    foreach ($query->getValues() as $key => $value) {
-                        $binds[":{$placeholder}_{$key}"] = json_encode($value);
-                        $conditions[] = "JSON_CONTAINS({$alias}.{$attribute}, :{$placeholder}_{$key})";
-                    }
-                    if (empty($conditions)) {
-                        return '';
-                    }
-                    $expression = '(' . implode(' OR ', $conditions) . ')';
-                    return $isNot ? "NOT {$expression}" : $expression;
-                }
-                // no break
-            default:
-                $conditions = [];
-                $isNotQuery = in_array($query->getMethod(), [
-                    Query::TYPE_NOT_STARTS_WITH,
-                    Query::TYPE_NOT_ENDS_WITH,
-                    Query::TYPE_NOT_CONTAINS
-                ]);
-
-                foreach ($query->getValues() as $key => $value) {
-                    $value = match ($query->getMethod()) {
-                        Query::TYPE_STARTS_WITH => $this->escapeWildcards($value) . '%',
-                        Query::TYPE_NOT_STARTS_WITH => $this->escapeWildcards($value) . '%',
-                        Query::TYPE_ENDS_WITH => '%' . $this->escapeWildcards($value),
-                        Query::TYPE_NOT_ENDS_WITH => '%' . $this->escapeWildcards($value),
-                        Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_NOT_CONTAINS => '%' . $this->escapeWildcards($value) . '%',
-                        default => $value
-                    };
-
-                    $binds[":{$placeholder}_{$key}"] = $value;
-                    if ($isNotQuery) {
-                        $conditions[] = "{$alias}.{$attribute} NOT {$this->getSQLOperator($query->getMethod())} :{$placeholder}_{$key}";
-                    } else {
-                        $conditions[] = "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())} :{$placeholder}_{$key}";
+        $exception = null;
+        try {
+            return parent::execute($stmt, $event);
+        } catch (Throwable $error) {
+            $exception = $error;
+            throw $error;
+        } finally {
+            if ($timeout !== $baseline) {
+                try {
+                    $this->applyTimeout($baseline);
+                } catch (Throwable $error) {
+                    if ($exception === null) {
+                        throw $error;
                     }
                 }
-
-                $separator = $isNotQuery ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
+            }
         }
     }
 
-    /**
-     * Get SQL Type
-     *
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param bool $required
-     * @return string
-     * @throws DatabaseException
-     */
-    protected function getSQLType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    private function applyTimeout(int $milliseconds): void
     {
-        if (in_array($type, Database::SPATIAL_TYPES)) {
-            return $this->getSpatialSQLType($type, $required);
-        }
-        if ($array === true) {
-            return 'JSON';
+        $seconds = $milliseconds > 0 ? $milliseconds / 1000.0 : 0.0;
+        if ($seconds === $this->appliedMaxStatementTime) {
+            return;
         }
 
-        switch ($type) {
-            case Database::VAR_ID:
-                return 'BIGINT UNSIGNED';
-
-            case Database::VAR_STRING:
-                // $size = $size * 4; // Convert utf8mb4 size to bytes
-                if ($size > Database::MAX_MEDIUMTEXT_BYTES) {
-                    return 'LONGTEXT';
-                }
-
-                if ($size > Database::MAX_TEXT_BYTES) {
-                    return 'MEDIUMTEXT';
-                }
-
-                if ($size > $this->getMaxVarcharLength()) {
-                    return 'TEXT';
-                }
-
-                return "VARCHAR({$size})";
-
-            case Database::VAR_VARCHAR:
-                if ($size <= 0) {
-                    throw new DatabaseException('VARCHAR size ' . $size . ' is invalid; must be > 0. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
-                }
-                if ($size > $this->getMaxVarcharLength()) {
-                    throw new DatabaseException('VARCHAR size ' . $size . ' exceeds maximum varchar length ' . $this->getMaxVarcharLength() . '. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
-                }
-                return "VARCHAR({$size})";
-
-            case Database::VAR_TEXT:
-                return 'TEXT';
+        $this->getPDO()->exec('SET max_statement_time = '.\sprintf('%.6F', $seconds));
+        $this->appliedMaxStatementTime = $seconds;
+    }
 
-            case Database::VAR_MEDIUMTEXT:
-                return 'MEDIUMTEXT';
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+        $tenant = Storage::TENANT;
 
-            case Database::VAR_LONGTEXT:
-                return 'LONGTEXT';
+        return "IF({$tenant} = VALUES({$tenant}), VALUES({$quoted}), {$quoted})";
+    }
 
-            case Database::VAR_INTEGER:  // We don't support zerofill: https://stackoverflow.com/a/5634147/2299554
-                $signed = ($signed) ? '' : ' UNSIGNED';
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
 
-                if ($size >= 8) { // INT = 4 bytes, BIGINT = 8 bytes
-                    return 'BIGINT' . $signed;
-                }
+        return "{$quoted} + VALUES({$quoted})";
+    }
 
-                return 'INT' . $signed;
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+        $tenant = Storage::TENANT;
 
-            case Database::VAR_BIGINT:
-                $signed = ($signed) ? '' : ' UNSIGNED';
-                return 'BIGINT' . $signed;
+        return "IF({$tenant} = VALUES({$tenant}), {$quoted} + VALUES({$quoted}), {$quoted})";
+    }
 
-            case Database::VAR_FLOAT:
-                $signed = ($signed) ? '' : ' UNSIGNED';
-                return 'DOUBLE' . $signed;
+    /**
+     * Handle distance spatial queries
+     *
+     * @param  array<string, mixed>  $binds
+     */
+    protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
+    {
+        /** @var array<mixed> $distanceParams */
+        $distanceParams = $query->getValues()[0];
+        /** @var array<mixed> $geomArray */
+        $geomArray = \is_array($distanceParams[0]) ? $distanceParams[0] : [];
+        $wkt = $this->convertArrayToWKT($geomArray);
+        $binds[":{$placeholder}_0"] = $wkt;
+        $binds[":{$placeholder}_1"] = $distanceParams[1];
 
-            case Database::VAR_BOOLEAN:
-                return 'TINYINT(1)';
+        $useMeters = isset($distanceParams[2]) && $distanceParams[2] === true;
 
-            case Database::VAR_RELATIONSHIP:
-                return 'VARCHAR(255)';
+        $operator = match ($query->getMethod()) {
+            Method::DistanceEqual => '=',
+            Method::DistanceNotEqual => '!=',
+            Method::DistanceGreaterThan => '>',
+            Method::DistanceLessThan => '<',
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
+        };
 
-            case Database::VAR_DATETIME:
-                return 'DATETIME(3)';
+        if ($useMeters) {
+            $wktType = $this->getSpatialTypeFromWKT($wkt);
+            $attrType = strtolower($type);
+            if ($wktType != ColumnType::Point->value || $attrType != ColumnType::Point->value) {
+                throw new QueryException('Distance in meters is not supported between '.$attrType.' and '.$wktType);
+            }
 
-            default:
-                throw new DatabaseException('Unknown type: ' . $type . '. Must be one of ' . Database::VAR_STRING . ', ' . Database::VAR_VARCHAR . ', ' . Database::VAR_TEXT . ', ' . Database::VAR_MEDIUMTEXT . ', ' . Database::VAR_LONGTEXT . ', ' . Database::VAR_INTEGER . ', ' . Database::VAR_BIGINT . ', ' . Database::VAR_FLOAT . ', ' . Database::VAR_BOOLEAN . ', ' . Database::VAR_DATETIME . ', ' . Database::VAR_RELATIONSHIP . ', ' . Database::VAR_POINT . ', ' . Database::VAR_LINESTRING . ', ' . Database::VAR_POLYGON);
+            return "ST_DISTANCE_SPHERE({$alias}.{$attribute}, ".$this->getSpatialGeomFromText(":{$placeholder}_0", null).', '.Database::EARTH_RADIUS.") {$operator} :{$placeholder}_1";
         }
+
+        return "ST_Distance({$alias}.{$attribute}, ".$this->getSpatialGeomFromText(":{$placeholder}_0", null).") {$operator} :{$placeholder}_1";
     }
 
     /**
-     * Get PDO Type
+     * Handle spatial queries
      *
-     * @param mixed $value
-     * @return int
-     * @throws Exception
+     * @param  array<string, mixed>  $binds
      */
-    protected function getPDOType(mixed $value): int
+    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
     {
-        return match (gettype($value)) {
-            'string','double' => \PDO::PARAM_STR,
-            'integer', 'boolean' => \PDO::PARAM_INT,
-            'NULL' => \PDO::PARAM_NULL,
-            default => throw new DatabaseException('Unknown PDO Type for ' . \gettype($value)),
+        /** @var array<mixed> $spatialGeomArr */
+        $spatialGeomArr = \is_array($query->getValues()[0]) ? $query->getValues()[0] : [];
+        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($spatialGeomArr);
+        $geom = $this->getSpatialGeomFromText(":{$placeholder}_0", null);
+
+        return match ($query->getMethod()) {
+            Method::Crosses => "ST_Crosses({$alias}.{$attribute}, {$geom})",
+            Method::NotCrosses => "NOT ST_Crosses({$alias}.{$attribute}, {$geom})",
+            Method::DistanceEqual,
+            Method::DistanceNotEqual,
+            Method::DistanceGreaterThan,
+            Method::DistanceLessThan => $this->handleDistanceSpatialQueries($query, $binds, $attribute, $type, $alias, $placeholder),
+            Method::Intersects => "ST_Intersects({$alias}.{$attribute}, {$geom})",
+            Method::NotIntersects => "NOT ST_Intersects({$alias}.{$attribute}, {$geom})",
+            Method::Overlaps => "ST_Overlaps({$alias}.{$attribute}, {$geom})",
+            Method::NotOverlaps => "NOT ST_Overlaps({$alias}.{$attribute}, {$geom})",
+            Method::Touches => "ST_Touches({$alias}.{$attribute}, {$geom})",
+            Method::NotTouches => "NOT ST_Touches({$alias}.{$attribute}, {$geom})",
+            Method::Equal => "ST_Equals({$alias}.{$attribute}, {$geom})",
+            Method::NotEqual => "NOT ST_Equals({$alias}.{$attribute}, {$geom})",
+            Method::Contains => "ST_Contains({$alias}.{$attribute}, {$geom})",
+            Method::NotContains => "NOT ST_Contains({$alias}.{$attribute}, {$geom})",
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
         };
     }
 
+    protected function createBuilder(): SQLBuilder
+    {
+        return new MariaDBBuilder();
+    }
+
+    #[\Override]
+    protected function createSchemaBuilder(): MySQLSchema
+    {
+        return new MySQLSchema();
+    }
+
     /**
-     * Get the SQL function for random ordering
-     *
-     * @return string
+     * Get the SQL function for random ordering.
      */
     protected function getRandomOrder(): string
     {
@@ -1706,275 +1202,62 @@ protected function getRandomOrder(): string
     }
 
     /**
-     * Size of POINT spatial type
+     * Get Schema Attributes
      *
-     * @return int
-    */
-    protected function getMaxPointSize(): int
-    {
-        // https://dev.mysql.com/doc/refman/8.4/en/gis-data-formats.html#gis-internal-format
-        return 25;
-    }
-
-    public function getMinDateTime(): \DateTime
-    {
-        return new \DateTime('1000-01-01 00:00:00');
-    }
-
-    public function getMaxDateTime(): \DateTime
-    {
-        return new \DateTime('9999-12-31 23:59:59');
-    }
-
-    /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Does the adapter handle Query Array Overlaps?
-     *
-     * @return bool
-     */
-    public function getSupportForJSONOverlaps(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Are timeouts supported?
+     * @return array<Document>
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForTimeouts(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpserts(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return true;
-    }
-
-    public function getSchemaIndexes(string $collection): array
+    public function getSchemaAttributes(string $collection): array
     {
         $schema = $this->getDatabase();
-        $collection = $this->getNamespace() . '_' . $this->filter($collection);
+        $collection = $this->getNamespace().'_'.$this->filter($collection);
 
         try {
-            $stmt = $this->getPDO()->prepare('
+            $stmt = $this->prepareStatement('
                 SELECT
-                    INDEX_NAME as indexName,
-                    COLUMN_NAME as columnName,
-                    NON_UNIQUE as nonUnique,
-                    SEQ_IN_INDEX as seqInIndex,
-                    INDEX_TYPE as indexType,
-                    SUB_PART as subPart
-                FROM INFORMATION_SCHEMA.STATISTICS
+                COLUMN_NAME as '.Storage::SEQUENCE.',
+                COLUMN_DEFAULT as columnDefault,
+                IS_NULLABLE as isNullable,
+                DATA_TYPE as dataType,
+                CHARACTER_MAXIMUM_LENGTH as characterMaximumLength,
+                NUMERIC_PRECISION as numericPrecision,
+                NUMERIC_SCALE as numericScale,
+                DATETIME_PRECISION as datetimePrecision,
+                COLUMN_TYPE as columnType,
+                COLUMN_KEY as columnKey,
+                EXTRA as extra
+                FROM INFORMATION_SCHEMA.COLUMNS
                 WHERE TABLE_SCHEMA = :schema AND TABLE_NAME = :table
-                ORDER BY INDEX_NAME, SEQ_IN_INDEX
-            ');
+            ', Event::CollectionRead);
             $stmt->bindParam(':schema', $schema);
             $stmt->bindParam(':table', $collection);
-            $stmt->execute();
-            $rows = $stmt->fetchAll();
+            $this->execute($stmt);
+            $results = $stmt->fetchAll();
             $stmt->closeCursor();
 
-            $grouped = [];
-            foreach ($rows as $row) {
-                $name = $row['indexName'];
-                if (!isset($grouped[$name])) {
-                    $grouped[$name] = [
-                        '$id' => $name,
-                        'indexName' => $name,
-                        'indexType' => $row['indexType'],
-                        'nonUnique' => (int)$row['nonUnique'],
-                        'columns' => [],
-                        'lengths' => [],
-                    ];
-                }
-                $grouped[$name]['columns'][] = $row['columnName'];
-                $grouped[$name]['lengths'][] = $row['subPart'] !== null ? (int)$row['subPart'] : null;
-            }
-
-            return \array_map(fn ($idx) => new Document($idx), \array_values($grouped));
-        } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get schema indexes', $e->getCode(), $e);
-        }
-    }
-
-    /**
-     * Set max execution time
-     * @param int $milliseconds
-     * @param string $event
-     * @return void
-     * @throws DatabaseException
-     */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
-    {
-        if (!$this->getSupportForTimeouts()) {
-            return;
-        }
-        if ($milliseconds <= 0) {
-            throw new DatabaseException('Timeout must be greater than 0');
-        }
-
-        $this->timeout = $milliseconds;
-
-        $seconds = $milliseconds / 1000;
-
-        $this->before($event, 'timeout', function ($sql) use ($seconds) {
-            return "SET STATEMENT max_statement_time = {$seconds} FOR " . $sql;
-        });
-    }
-
-    /**
-     * @return string
-     */
-    public function getConnectionId(): string
-    {
-        $stmt = $this->getPDO()->query("SELECT CONNECTION_ID();");
-        return $stmt->fetchColumn();
-    }
-
-    public function getInternalIndexesKeys(): array
-    {
-        return ['primary', '_created_at', '_updated_at', '_tenant_id'];
-    }
-
-    protected function processException(PDOException $e): \Exception
-    {
-        if ($e->getCode() === '22007' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1366) {
-            return new CharacterException('Invalid character', $e->getCode(), $e);
-        }
+            $docs = [];
+            foreach ($results as $document) {
+                /** @var array<string, mixed> $document */
+                $document[Document::ID] = $document[Storage::SEQUENCE];
+                unset($document[Storage::SEQUENCE]);
 
-        // Timeout
-        if ($e->getCode() === '70100' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1969) {
-            return new TimeoutException('Query timed out', $e->getCode(), $e);
-        }
-
-        // Duplicate table
-        if ($e->getCode() === '42S01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1050) {
-            return new DuplicateException('Collection already exists', $e->getCode(), $e);
-        }
-
-        // Duplicate column
-        if ($e->getCode() === '42S21' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1060) {
-            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
-        }
-
-        // Duplicate index
-        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1061) {
-            return new DuplicateException('Index already exists', $e->getCode(), $e);
-        }
-
-        // Duplicate row
-        if ($e->getCode() === '23000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1062) {
-            $key = $this->getViolatedKey($e->getMessage());
-            if ($key === '_index1') {
-                return new DuplicateException('Duplicate permissions for document', $e->getCode(), $e);
-            }
-            if ($key !== null && $key !== '_uid' && $key !== 'PRIMARY') {
-                return new UniqueException('Unique index violation', $e->getCode(), $e);
+                $docs[] = new Document($document);
             }
-            return new DuplicateException('Document already exists', $e->getCode(), $e);
-        }
-
-        // Data is too big for column resize
-        if (($e->getCode() === '22001' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1406) ||
-            ($e->getCode() === '01000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1265)) {
-            return new TruncateException('Resize would result in data truncation', $e->getCode(), $e);
-        }
-
-        // Numeric value out of range
-        if ($e->getCode() === '22003' && isset($e->errorInfo[1]) && ($e->errorInfo[1] === 1264 || $e->errorInfo[1] === 1690)) {
-            return new LimitException('Value out of range', $e->getCode(), $e);
-        }
-
-        // Numeric value out of range
-        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1690) {
-            return new LimitException('Value is out of range', $e->getCode(), $e);
-        }
-
-        // Unknown database
-        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
-            return new NotFoundException('Database not found', $e->getCode(), $e);
-        }
+            $results = $docs;
 
-        // Unknown collection
-        if ($e->getCode() === '42S02' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
-            return new NotFoundException('Collection not found', $e->getCode(), $e);
-        }
-
-        // Unknown collection
-        // We have two of same, because docs point to 1051.
-        // Keeping previous 1049 (above) just in case it's for older versions
-        if ($e->getCode() === '42S02' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1051) {
-            return new NotFoundException('Collection not found', $e->getCode(), $e);
-        }
-
-        // Unknown column
-        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1091) {
-            return new NotFoundException('Attribute not found', $e->getCode(), $e);
-        }
-
-        return $e;
-    }
+            return $results;
 
-    /**
-     * Extract the index name from a duplicate entry error, e.g.
-     * "Duplicate entry 'x' for key 'movies._uid'" resolves to "_uid".
-     * Returns null when the message cannot be parsed.
-     */
-    protected function getViolatedKey(string $message): ?string
-    {
-        if (\preg_match("/for key '(?:[^'.]*\.)?([^']+)'/", $message, $matches) === 1) {
-            return $matches[1];
+        } catch (PDOException $e) {
+            throw new DatabaseException('Failed to get schema attributes', $e->getCode(), $e);
         }
-
-        return null;
-    }
-
-    protected function quote(string $string): string
-    {
-        return "`{$string}`";
     }
 
     /**
      * Get operator SQL
      * Override to handle MariaDB/MySQL-specific operators
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param array<string, mixed> $binds
-     * @return ?string
      */
-    protected function getOperatorSQL(string $column, Operator $operator, array &$binds): ?string
+    protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
         $quotedColumn = $this->quote($column);
         $method = $operator->getMethod();
@@ -1982,161 +1265,171 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Increment:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
-                    // Compare with the operand moved across (`col > max - val`) instead of
-                    // `col + val > max`, so the guard never overflows BIGINT when col is near the
-                    // integer range limit. Inclusive: a result landing exactly on max still applies.
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) > :$maxKey - :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) + :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Decrement:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
-                    // `col < min + val` rather than `col - val < min`: overflow-safe near the
-                    // integer range limit. Inclusive: a result landing exactly on min still applies.
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) < :$minKey + :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) - :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Multiply:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
-                    // Compare via division (`col > max/val`, sign-aware) instead of computing
-                    // `col * val`, which would overflow BIGINT for large operands. The factor's
-                    // sign flips the inequality. Inclusive: a result exactly on max still applies.
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN :$bindKey > 0 AND COALESCE({$quotedColumn}, 0) > :$maxKey / :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         WHEN :$bindKey < 0 AND COALESCE({$quotedColumn}, 0) < :$maxKey / :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) * :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Divide:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN :$bindKey != 0 AND COALESCE({$quotedColumn}, 0) / :$bindKey < :$minKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) / :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Modulo:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = MOD(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
-            case Operator::TYPE_POWER:
+            case OperatorType::Power:
                 $exponent = $values[0] ?? 1;
-                $bindKey = $this->registerOperatorBind($binds, $exponent);
+                if (! \is_int($exponent) && ! \is_float($exponent)) {
+                    throw new OperatorException('Power exponent must be numeric');
+                }
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
-                    $col = "COALESCE({$quotedColumn}, 0)";
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
 
-                    // Leave the value unchanged only for undefined inputs, then apply the power if
-                    // the result stays within the max. The exponent is constant, so only the
-                    // undefined guard its value can actually trigger is emitted.
+                    $columnValue = "COALESCE({$quotedColumn}, 0)";
                     $oddInteger = \floor($exponent) == $exponent && ((int) $exponent) % 2 !== 0;
+                    $guards = [];
 
-                    $whens = [];
                     if ($exponent < 0) {
-                        // 0 to a negative power is undefined (POWER would error / return NULL).
-                        $whens[] = "WHEN {$col} = 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} = 0 THEN {$columnValue}";
                     }
                     if (\floor($exponent) != $exponent) {
-                        // A negative base to a fractional exponent is not a real number.
-                        $whens[] = "WHEN {$col} < 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} < 0 THEN {$columnValue}";
                     }
-                    // Cap by magnitude via logarithms so POWER() never runs on a value that would
-                    // overflow (base^exp > max  <=>  exp * LOG(base) > LOG(max)).
                     if ($exponent == 0) {
-                        // Every base to the zeroth power is 1 (including 0^0), which the magnitude
-                        // check below can't see for a base of 0. The result 1 exceeds the max when
-                        // max < 1, i.e. LOG(max) < 0 (LOG also coerces the bound value numerically).
-                        $whens[] = "WHEN LOG(:$maxKey) < 0 THEN {$col}";
+                        $guards[] = "WHEN LOG(:$maxKey) < 0 THEN {$columnValue}";
                     } elseif ($oddInteger) {
-                        // An odd exponent keeps a negative base negative, and a negative result is
-                        // always within a positive max, so only cap positive bases; negative bases
-                        // fall through to POWER() and their (negative) result is applied.
-                        $whens[] = "WHEN {$col} > 0 AND :$bindKey * LOG({$col}) > LOG(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} > 0 AND :$bindKey * LOG({$columnValue}) > LOG(:$maxKey) THEN {$columnValue}";
                     } else {
-                        // Otherwise the result is non-negative, so its magnitude equals its value —
-                        // cap either sign. ABS() keeps LOG() defined for a negative even-power base.
-                        $whens[] = "WHEN {$col} <> 0 AND :$bindKey * LOG(ABS({$col})) > LOG(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} <> 0 AND :$bindKey * LOG(ABS({$columnValue})) > LOG(:$maxKey) THEN {$columnValue}";
                     }
 
-                    $whenSql = \implode(' ', $whens);
-                    return "{$quotedColumn} = CASE {$whenSql} ELSE POWER({$col}, :$bindKey) END";
+                    return "{$quotedColumn} = CASE ".\implode(' ', $guards)." ELSE POWER({$columnValue}, :$bindKey) END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? '');
+            case OperatorType::StringConcat:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = CONCAT(COALESCE({$quotedColumn}, ''), :$bindKey)";
 
-            case Operator::TYPE_STRING_REPLACE:
-                $searchKey = $this->registerOperatorBind($binds, $values[0] ?? '');
-                $replaceKey = $this->registerOperatorBind($binds, $values[1] ?? '');
+            case OperatorType::StringReplace:
+                $searchKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $replaceKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = REPLACE({$quotedColumn}, :$searchKey, :$replaceKey)";
 
                 // Boolean operators
-            case Operator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 return "{$quotedColumn} = NOT COALESCE({$quotedColumn}, FALSE)";
 
                 // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayAppend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(IFNULL({$quotedColumn}, JSON_ARRAY()), :$bindKey)";
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayPrepend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(:$bindKey, IFNULL({$quotedColumn}, JSON_ARRAY()))";
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $indexKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
-                $valueKey = $this->registerOperatorBind($binds, json_encode($values[1] ?? null));
+            case OperatorType::ArrayInsert:
+                $indexKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = JSON_ARRAY_INSERT(
                     {$quotedColumn},
                     CONCAT('$[', :$indexKey, ']'),
                     JSON_EXTRACT(:$valueKey, '$')
                 )";
 
-            case Operator::TYPE_ARRAY_REMOVE:
-                $removeValue = $values[0] ?? null;
-                // Cast scalars to string so the value binds as PDO::PARAM_STR, preserving the
-                // pre-refactor behavior (it was bound with an explicit PARAM_STR). JSON_TABLE
-                // extracts `value` as TEXT, so the search term must compare as text — without
-                // the cast, getPDOType() would bind a number as PARAM_INT. Do not drop it.
-                $removeValue = is_array($removeValue) ? json_encode($removeValue) : (string)$removeValue;
-                $bindKey = $this->registerOperatorBind($binds, $removeValue);
+            case OperatorType::ArrayRemove:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(value)
                     FROM JSON_TABLE({$quotedColumn}, '\$[*]' COLUMNS(value TEXT PATH '\$')) AS jt
                     WHERE value != :$bindKey
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(DISTINCT jt.value)
                     FROM JSON_TABLE({$quotedColumn}, '\$[*]' COLUMNS(value TEXT PATH '\$')) AS jt
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayIntersect:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(jt1.value)
                     FROM JSON_TABLE({$quotedColumn}, '\$[*]' COLUMNS(value TEXT PATH '\$')) AS jt1
@@ -2146,8 +1439,10 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     )
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_DIFF:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayDiff:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(jt1.value)
                     FROM JSON_TABLE({$quotedColumn}, '\$[*]' COLUMNS(value TEXT PATH '\$')) AS jt1
@@ -2157,11 +1452,12 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     )
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_FILTER:
-                $condition = $values[0] ?? 'equal';
-                $filterValue = $values[1] ?? null;
-                $conditionKey = $this->registerOperatorBind($binds, $condition);
-                $valueKey = $this->registerOperatorBind($binds, $filterValue === null ? null : json_encode($filterValue));
+            case OperatorType::ArrayFilter:
+                $conditionKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(value)
                     FROM JSON_TABLE({$quotedColumn}, '\$[*]' COLUMNS(value TEXT PATH '\$')) AS jt
@@ -2179,170 +1475,181 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                 ), JSON_ARRAY())";
 
                 // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateAddDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = DATE_ADD({$quotedColumn}, INTERVAL :$bindKey DAY)";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateSubDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = DATE_SUB({$quotedColumn}, INTERVAL :$bindKey DAY)";
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return "{$quotedColumn} = NOW()";
 
             default:
-                throw new OperatorException("Invalid operator: {$method}");
+                throw new OperatorException('Invalid operator');
         }
     }
 
-    public function getSupportForNumericCasting(): bool
+    protected function getSearchRelevanceRaw(Query $query, string $alias): ?array
     {
-        return true;
-    }
+        [$quotedAlias, $quotedAttribute] = $this->quoteSearchAttribute($query->getAttribute(), $alias);
+        $searchVal = $query->getValue();
+        $term = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
 
-    public function getSupportForIndexArray(): bool
-    {
-        return true;
+        return [
+            'expression' => "MATCH({$quotedAlias}.{$quotedAttribute}) AGAINST (? IN BOOLEAN MODE) AS `_relevance`",
+            'order' => '`_relevance` DESC',
+            'bindings' => [$term],
+        ];
     }
 
-    public function getSupportForSpatialAttributes(): bool
+    public function getSchemaIndexes(string $collection): array
     {
-        return true;
-    }
+        $schema = $this->getDatabase();
+        $collection = $this->getNamespace() . '_' . $this->filter($collection);
 
-    public function getSupportForObject(): bool
-    {
-        return false;
-    }
+        try {
+            $stmt = $this->prepareStatement('
+                SELECT
+                    INDEX_NAME as indexName,
+                    COLUMN_NAME as columnName,
+                    NON_UNIQUE as nonUnique,
+                    SEQ_IN_INDEX as seqInIndex,
+                    INDEX_TYPE as indexType,
+                    SUB_PART as subPart
+                FROM INFORMATION_SCHEMA.STATISTICS
+                WHERE TABLE_SCHEMA = :schema AND TABLE_NAME = :table
+                ORDER BY INDEX_NAME, SEQ_IN_INDEX
+            ', Event::CollectionRead);
+            $stmt->bindParam(':schema', $schema);
+            $stmt->bindParam(':table', $collection);
+            $this->execute($stmt);
+            $rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
+            $stmt->closeCursor();
 
-    public function getSupportForUnsignedBigInt(): bool
-    {
-        return true;
-    }
+            $grouped = [];
+            foreach ($rows as $row) {
+                if (! \is_array($row)) {
+                    continue;
+                }
+                $name = \is_string($row['indexName'] ?? null) ? $row['indexName'] : '';
+                if ($name === '') {
+                    continue;
+                }
+                if (!isset($grouped[$name])) {
+                    $indexType = \is_string($row['indexType'] ?? null) ? $row['indexType'] : '';
+                    $nonUnique = \is_numeric($row['nonUnique'] ?? null) ? (int) $row['nonUnique'] : 0;
+                    $grouped[$name] = [
+                        Document::ID => $name,
+                        'indexName' => $name,
+                        'indexType' => $indexType,
+                        'nonUnique' => $nonUnique,
+                        'columns' => [],
+                        'lengths' => [],
+                    ];
+                }
+                $grouped[$name]['columns'][] = \is_string($row['columnName'] ?? null) ? $row['columnName'] : '';
+                $subPart = $row['subPart'] ?? null;
+                $grouped[$name]['lengths'][] = \is_numeric($subPart) ? (int) $subPart : null;
+            }
 
-    /**
-     * Are object (JSON) indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
+            return \array_map(fn ($idx) => new Document($idx), \array_values($grouped));
+        } catch (PDOException $e) {
+            throw new DatabaseException('Failed to get schema indexes', $e->getCode(), $e);
+        }
     }
 
-    /**
-     * Get Support for Null Values in Spatial Indexes
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialIndexNull(): bool
+    protected function processException(PDOException $e): Exception
     {
-        return false;
-    }
-    /**
-     * Does the adapter includes boundary during spatial contains?
-     *
-     * @return bool
-     */
+        if ($e->getCode() === '22007' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1366) {
+            return new CharacterException('Invalid character', $e->getCode(), $e);
+        }
 
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return true;
-    }
-    /**
-     * Does the adapter support order attribute in spatial indexes?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return true;
-    }
+        // Timeout
+        if ($e->getCode() === '70100' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1969) {
+            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        }
 
-    /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
-     *
-     * @return bool
-    */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return false;
-    }
+        // Duplicate table
+        if ($e->getCode() === '42S01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1050) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
+        }
 
-    public function getSpatialSQLType(string $type, bool $required): string
-    {
-        $srid = Database::DEFAULT_SRID;
-        $nullability = '';
+        // Duplicate column
+        if ($e->getCode() === '42S21' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1060) {
+            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
+        }
 
-        if (!$this->getSupportForSpatialIndexNull()) {
-            if ($required) {
-                $nullability = ' NOT NULL';
-            } else {
-                $nullability = ' NULL';
-            }
+        // Duplicate index
+        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1061) {
+            return new DuplicateException('Index already exists', $e->getCode(), $e);
         }
 
-        switch ($type) {
-            case Database::VAR_POINT:
-                return "POINT($srid)$nullability";
+        // Duplicate row
+        if ($e->getCode() === '23000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1062) {
+            $key = $this->getViolatedKey($e->getMessage());
+            if ($key === Storage::INDEX_1) {
+                return new DuplicateException('Duplicate permissions for document', $e->getCode(), $e);
+            }
+            if ($key !== null && $key !== Storage::UID && $key !== 'PRIMARY') {
+                return new UniqueException('Unique index violation', $e->getCode(), $e);
+            }
 
-            case Database::VAR_LINESTRING:
-                return "LINESTRING($srid)$nullability";
+            return new DuplicateException('Document already exists', $e->getCode(), $e);
+        }
 
-            case Database::VAR_POLYGON:
-                return "POLYGON($srid)$nullability";
+        // Data is too big for column resize
+        if (($e->getCode() === '22001' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1406) ||
+            ($e->getCode() === '01000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1265)) {
+            return new TruncateException('Resize would result in data truncation', $e->getCode(), $e);
         }
 
-        return '';
-    }
+        // Numeric value out of range
+        if ($e->getCode() === '22003' && isset($e->errorInfo[1]) && ($e->errorInfo[1] === 1264 || $e->errorInfo[1] === 1690)) {
+            return new LimitException('Value out of range', $e->getCode(), $e);
+        }
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+        // Numeric value out of range
+        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1690) {
+            return new LimitException('Value is out of range', $e->getCode(), $e);
+        }
 
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
-     */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return true;
-    }
+        // Unknown database
+        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
+            return new NotFoundException('Database not found', $e->getCode(), $e);
+        }
 
-    public function getSupportForAlterLocks(): bool
-    {
-        return true;
-    }
+        // Unknown collection
+        if ($e->getCode() === '42S02' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
+            return new NotFoundException('Collection not found', $e->getCode(), $e);
+        }
 
-    public function getSupportNonUtfCharacters(): bool
-    {
-        return true;
-    }
+        // Unknown collection
+        // We have two of same, because docs point to 1051.
+        // Keeping previous 1049 (above) just in case it's for older versions
+        if ($e->getCode() === '42S02' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1051) {
+            return new NotFoundException('Collection not found', $e->getCode(), $e);
+        }
 
-    public function getSupportForTrigramIndex(): bool
-    {
-        return false;
-    }
+        // Unknown column
+        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1091) {
+            return new NotFoundException('Attribute not found', $e->getCode(), $e);
+        }
 
-    public function getSupportForPCRERegex(): bool
-    {
-        return true;
+        return $e;
     }
 
-    public function getSupportForPOSIXRegex(): bool
+    protected function getViolatedKey(string $message): ?string
     {
-        return false;
-    }
+        if (\preg_match("/for key '(?:[^'.]*\.)?([^']+)'/", $message, $matches) !== 1) {
+            return null;
+        }
 
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
+        return $matches[1];
     }
 }
diff --git a/src/Database/Adapter/Memory.php b/src/Database/Adapter/Memory.php
index 5e126a7177..a91b3e54b5 100644
--- a/src/Database/Adapter/Memory.php
+++ b/src/Database/Adapter/Memory.php
@@ -3,6 +3,8 @@
 namespace Utopia\Database\Adapter;
 
 use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -10,10 +12,22 @@
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
-use Utopia\Database\Exception\Operator as OperatorException;
 use Utopia\Database\Exception\Unique as UniqueException;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Method;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 /**
  * In-process drop-in for the SQL adapters that keeps all data in PHP
@@ -28,7 +42,7 @@
  * Spatial types and vector search throw a DatabaseException — those
  * features only make sense against a real engine.
  */
-class Memory extends Adapter
+class Memory extends Adapter implements Feature\Relationships
 {
     /**
      * Map of database name to the set of collection storage keys it owns.
@@ -101,6 +115,32 @@ public function getDriver(): mixed
         return 'memory';
     }
 
+    /**
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::Schemas,
+            Capability::Fulltext,
+            Capability::Casting,
+            Capability::QueryContains,
+            Capability::BatchOperations,
+            Capability::BatchCreateAttributes,
+            Capability::AttributeResizing,
+            Capability::Objects,
+            Capability::ObjectIndexes,
+            Capability::Operators,
+            Capability::OrderRandom,
+            Capability::DefinedAttributes,
+            Capability::NestedTransactions,
+            Capability::PCRE,
+            Capability::Regex,
+            Capability::BoundaryInclusive,
+            Capability::Caching,
+        ]);
+    }
+
     protected function key(string $collection): string
     {
         // Schema scoping: prefix the storage key with the current database
@@ -137,9 +177,11 @@ protected function locateDocument(string $key, string $collectionId, string $id)
         if ($this->sharedTables && $collectionId === Database::METADATA) {
             $lower = \strtolower($id);
             foreach ($this->data[$key]['documents'] as $storageKey => $candidate) {
+                $uid = $candidate[Storage::UID] ?? '';
                 if (
-                    \strtolower((string) ($candidate['_uid'] ?? '')) === $lower
-                    && ($candidate['_tenant'] ?? null) === null
+                    \is_string($uid)
+                    && \strtolower($uid) === $lower
+                    && ($candidate[Storage::TENANT] ?? null) === null
                 ) {
                     return [$storageKey, $candidate];
                 }
@@ -149,11 +191,6 @@ protected function locateDocument(string $key, string $collectionId, string $id)
         return null;
     }
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
-    {
-        // No-op: nothing to time out in-memory
-    }
-
     public function ping(): bool
     {
         return true;
@@ -360,22 +397,22 @@ public function createCollection(string $name, array $attributes = [], array $in
         }
 
         foreach ($attributes as $attribute) {
-            $attrId = $this->filter($attribute->getId());
+            $attrId = $this->filter($attribute->key);
             $this->data[$key]['attributes'][$attrId] = [
-                'type' => $attribute->getAttribute('type'),
-                'size' => $attribute->getAttribute('size', 0),
-                'signed' => $attribute->getAttribute('signed', true),
-                'array' => $attribute->getAttribute('array', false),
-                'required' => $attribute->getAttribute('required', false),
+                'type' => $attribute->type->value,
+                'size' => $attribute->size,
+                'signed' => $attribute->signed,
+                'array' => $attribute->array,
+                'required' => $attribute->required,
             ];
         }
 
         foreach ($indexes as $index) {
-            $indexId = $this->filter($index->getId());
+            $indexId = $this->filter($index->key);
             $this->data[$key]['indexes'][$indexId] = [
-                'type' => $index->getAttribute('type'),
-                'attributes' => $index->getAttribute('attributes', []),
-                'lengths' => $index->getAttribute('lengths', []),
+                'type' => $index->type->value,
+                'attributes' => $index->attributes,
+                'lengths' => $index->lengths,
                 'orders' => $index->getAttribute('orders', []),
             ];
         }
@@ -388,7 +425,7 @@ public function createCollection(string $name, array $attributes = [], array $in
                 $this->permissionsByPermission[$key],
                 $this->uniqueIndexHashes[$key],
             );
-            if ($database !== '' && $databaseSlot !== null) {
+            if ($databaseSlot !== null) {
                 unset($this->databases[$database][$databaseSlot]);
             }
         });
@@ -450,21 +487,21 @@ public function analyzeCollection(string $collection): bool
         return false;
     }
 
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
         $key = $this->key($collection);
         if (! isset($this->data[$key])) {
             throw new NotFoundException('Collection not found');
         }
 
-        $id = $this->filter($id);
+        $id = $this->filter($attribute->key);
         $previous = $this->data[$key]['attributes'][$id] ?? null;
         $this->data[$key]['attributes'][$id] = [
-            'type' => $type,
-            'size' => $size,
-            'signed' => $signed,
-            'array' => $array,
-            'required' => $required,
+            'type' => $attribute->type->value,
+            'size' => $attribute->size,
+            'signed' => $attribute->signed,
+            'array' => $attribute->array,
+            'required' => $attribute->required,
         ];
 
         $this->journal(function () use ($key, $id, $previous): void {
@@ -481,28 +518,20 @@ public function createAttribute(string $collection, string $id, string $type, in
     public function createAttributes(string $collection, array $attributes): bool
     {
         foreach ($attributes as $attribute) {
-            $this->createAttribute(
-                $collection,
-                (string) $attribute['$id'],
-                (string) $attribute['type'],
-                (int) ($attribute['size'] ?? 0),
-                (bool) ($attribute['signed'] ?? true),
-                (bool) ($attribute['array'] ?? false),
-                (bool) ($attribute['required'] ?? false),
-            );
+            $this->createAttribute($collection, $attribute);
         }
 
         return true;
     }
 
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
     {
         $key = $this->key($collection);
         if (! isset($this->data[$key])) {
             throw new NotFoundException('Collection not found');
         }
 
-        $id = $this->filter($id);
+        $id = $this->filter($attribute->key);
         if (! empty($newKey) && $newKey !== $id) {
             $this->renameAttribute($collection, $id, $newKey);
             $id = $this->filter($newKey);
@@ -510,11 +539,11 @@ public function updateAttribute(string $collection, string $id, string $type, in
 
         $previous = $this->data[$key]['attributes'][$id] ?? null;
         $this->data[$key]['attributes'][$id] = [
-            'type' => $type,
-            'size' => $size,
-            'signed' => $signed,
-            'array' => $array,
-            'required' => $required,
+            'type' => $attribute->type->value,
+            'size' => $attribute->size,
+            'signed' => $attribute->signed,
+            'array' => $attribute->array,
+            'required' => $attribute->required,
         ];
 
         $this->journal(function () use ($key, $id, $previous): void {
@@ -554,29 +583,34 @@ public function deleteAttribute(string $collection, string $id): bool
 
         $previousIndexes = [];
         $previousUniqueHashes = [];
-        foreach ($this->data[$key]['indexes'] as $indexId => &$index) {
-            $attributes = $index['attributes'] ?? [];
+        foreach ($this->data[$key]['indexes'] as $indexId => $index) {
+            $attributes = \is_array($index['attributes'] ?? null) ? $index['attributes'] : [];
+            $indexLengths = \is_array($index['lengths'] ?? null) ? $index['lengths'] : [];
+            $indexOrders = \is_array($index['orders'] ?? null) ? $index['orders'] : [];
             $filtered = [];
             $lengths = [];
             $orders = [];
             $touched = false;
             foreach ($attributes as $i => $attribute) {
+                if (! \is_string($attribute)) {
+                    continue;
+                }
                 if ($this->filter($attribute) === $id) {
                     $touched = true;
 
                     continue;
                 }
                 $filtered[] = $attribute;
-                if (isset($index['lengths'][$i])) {
-                    $lengths[] = $index['lengths'][$i];
+                if (isset($indexLengths[$i])) {
+                    $lengths[] = $indexLengths[$i];
                 }
-                if (isset($index['orders'][$i])) {
-                    $orders[] = $index['orders'][$i];
+                if (isset($indexOrders[$i])) {
+                    $orders[] = $indexOrders[$i];
                 }
             }
             if ($touched) {
                 $previousIndexes[$indexId] = $index;
-                if (($index['type'] ?? '') === Database::INDEX_UNIQUE
+                if (($index['type'] ?? '') === IndexType::Unique->value
                     && isset($this->uniqueIndexHashes[$key][$indexId])) {
                     $previousUniqueHashes[$indexId] = $this->uniqueIndexHashes[$key][$indexId];
                     unset($this->uniqueIndexHashes[$key][$indexId]);
@@ -585,21 +619,24 @@ public function deleteAttribute(string $collection, string $id): bool
             $index['attributes'] = $filtered;
             $index['lengths'] = $lengths;
             $index['orders'] = $orders;
+            $this->data[$key]['indexes'][$indexId] = $index;
         }
-        unset($index);
 
         $this->journal(function () use ($key, $id, $previousAttribute, $previousValues, $previousIndexes, $previousUniqueHashes): void {
+            if (! isset($this->data[$key])) {
+                return;
+            }
             $this->data[$key]['attributes'][$id] = $previousAttribute;
             foreach ($previousValues as $storageKey => $value) {
                 if (isset($this->data[$key]['documents'][$storageKey])) {
                     $this->data[$key]['documents'][$storageKey][$id] = $value;
                 }
             }
-            foreach ($previousIndexes as $indexId => $value) {
-                $this->data[$key]['indexes'][$indexId] = $value;
+            foreach ($previousIndexes as $indexId => $previousIndex) {
+                $this->data[$key]['indexes'][$indexId] = $previousIndex;
             }
-            foreach ($previousUniqueHashes as $indexId => $value) {
-                $this->uniqueIndexHashes[$key][$indexId] = $value;
+            foreach ($previousUniqueHashes as $indexId => $hashes) {
+                $this->uniqueIndexHashes[$key][$indexId] = $hashes;
             }
         });
 
@@ -635,10 +672,10 @@ public function renameAttribute(string $collection, string $old, string $new): b
 
         $touchedIndexes = [];
         foreach ($this->data[$key]['indexes'] as $indexId => &$index) {
-            $attributes = $index['attributes'] ?? [];
+            $attributes = \is_array($index['attributes'] ?? null) ? $index['attributes'] : [];
             $changed = false;
             foreach ($attributes as $i => $attribute) {
-                if ($this->filter($attribute) === $old) {
+                if (\is_string($attribute) && $this->filter($attribute) === $old) {
                     $attributes[$i] = $new;
                     $changed = true;
                 }
@@ -651,32 +688,40 @@ public function renameAttribute(string $collection, string $old, string $new): b
         unset($index);
 
         $this->journal(function () use ($key, $old, $new, $touchedDocs, $touchedIndexes): void {
-            $this->data[$key]['attributes'][$old] = $this->data[$key]['attributes'][$new];
-            unset($this->data[$key]['attributes'][$new]);
+            if (! isset($this->data[$key])) {
+                return;
+            }
+            $entry = &$this->data[$key];
+            $entry['attributes'][$old] = $entry['attributes'][$new];
+            unset($entry['attributes'][$new]);
             foreach ($touchedDocs as $storageKey) {
-                if (! isset($this->data[$key]['documents'][$storageKey])) {
+                if (! isset($entry['documents'][$storageKey])) {
                     continue;
                 }
-                $document = &$this->data[$key]['documents'][$storageKey];
+                $document = &$entry['documents'][$storageKey];
                 $document[$old] = $document[$new];
                 unset($document[$new]);
                 unset($document);
             }
             foreach ($touchedIndexes as $indexId) {
-                $attributes = $this->data[$key]['indexes'][$indexId]['attributes'] ?? [];
+                $attributes = \is_array($entry['indexes'][$indexId]['attributes'] ?? null)
+                    ? $entry['indexes'][$indexId]['attributes']
+                    : [];
                 foreach ($attributes as $i => $attribute) {
-                    if ($this->filter($attribute) === $new) {
+                    if (\is_string($attribute) && $this->filter($attribute) === $new) {
                         $attributes[$i] = $old;
                     }
                 }
-                $this->data[$key]['indexes'][$indexId]['attributes'] = $attributes;
+                $entry['indexes'][$indexId]['attributes'] = $attributes;
             }
+            unset($entry);
         });
 
         return true;
     }
 
-    public function createRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay = false, string $id = '', string $twoWayKey = ''): bool
+    #[\Override]
+    public function createRelationship(Relationship $relationship): bool
     {
         // Memory stores documents as flexible maps, so the relationship "column"
         // is registered on the attribute list rather than added as a physical
@@ -685,20 +730,26 @@ public function createRelationship(string $collection, string $relatedCollection
         // which selects the column even when no rows have a value.
         // The M2M junction collection itself is created by the wrapper through
         // the standard createCollection path.
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $id = $relationship->key;
+        $twoWayKey = $relationship->twoWayKey;
+        $twoWay = $relationship->twoWay;
+
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
                 $this->registerRelationshipField($collection, $id);
                 if ($twoWay) {
                     $this->registerRelationshipField($relatedCollection, $twoWayKey);
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
+            case RelationType::OneToMany:
                 $this->registerRelationshipField($relatedCollection, $twoWayKey);
                 break;
-            case Database::RELATION_MANY_TO_ONE:
+            case RelationType::ManyToOne:
                 $this->registerRelationshipField($collection, $id);
                 break;
-            case Database::RELATION_MANY_TO_MANY:
+            case RelationType::ManyToMany:
                 // Junction columns live on the junction collection, which is
                 // created with explicit attributes by the wrapper.
                 break;
@@ -709,15 +760,20 @@ public function createRelationship(string $collection, string $relatedCollection
         return true;
     }
 
-    public function updateRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side, ?string $newKey = null, ?string $newTwoWayKey = null): bool
+    #[\Override]
+    public function updateRelationship(Relationship $relationship, ?string $newKey = null, ?string $newTwoWayKey = null): bool
     {
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
         $newKey = $newKey !== null ? $this->filter($newKey) : null;
         $newTwoWayKey = $newTwoWayKey !== null ? $this->filter($newTwoWayKey) : null;
+        $side = $relationship->side;
+        $twoWay = $relationship->twoWay;
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
                 if ($newKey !== null && $newKey !== $key) {
                     $this->renameDocumentField($collection, $key, $newKey);
                 }
@@ -725,8 +781,8 @@ public function updateRelationship(string $collection, string $relatedCollection
                     $this->renameDocumentField($relatedCollection, $twoWayKey, $newTwoWayKey);
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
                     if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
                         $this->renameDocumentField($relatedCollection, $twoWayKey, $newTwoWayKey);
                     }
@@ -736,8 +792,8 @@ public function updateRelationship(string $collection, string $relatedCollection
                     }
                 }
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
                     if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
                         $this->renameDocumentField($relatedCollection, $twoWayKey, $newTwoWayKey);
                     }
@@ -747,7 +803,7 @@ public function updateRelationship(string $collection, string $relatedCollection
                     }
                 }
                 break;
-            case Database::RELATION_MANY_TO_MANY:
+            case RelationType::ManyToMany:
                 $junction = $this->resolveJunctionCollection($collection, $relatedCollection, $side);
                 if ($junction !== null) {
                     if ($newKey !== null && $newKey !== $key) {
@@ -765,14 +821,19 @@ public function updateRelationship(string $collection, string $relatedCollection
         return true;
     }
 
-    public function deleteRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side): bool
+    #[\Override]
+    public function deleteRelationship(Relationship $relationship): bool
     {
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($side === RelationSide::Parent) {
                     $this->dropDocumentField($collection, $key);
                     if ($twoWay) {
                         $this->dropDocumentField($relatedCollection, $twoWayKey);
@@ -784,21 +845,21 @@ public function deleteRelationship(string $collection, string $relatedCollection
                     }
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
                     $this->dropDocumentField($relatedCollection, $twoWayKey);
                 } else {
                     $this->dropDocumentField($collection, $key);
                 }
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
                     $this->dropDocumentField($collection, $key);
                 } else {
                     $this->dropDocumentField($relatedCollection, $twoWayKey);
                 }
                 break;
-            case Database::RELATION_MANY_TO_MANY:
+            case RelationType::ManyToMany:
                 // Junction collection is dropped by the wrapper via cleanupCollection.
                 break;
             default:
@@ -822,7 +883,7 @@ protected function registerRelationshipField(string $collection, string $field):
         $field = $this->filter($field);
         $previous = $this->data[$key]['attributes'][$field] ?? null;
         $this->data[$key]['attributes'][$field] = [
-            'type' => Database::VAR_RELATIONSHIP,
+            'type' => ColumnType::Relationship->value,
             'size' => 0,
             'signed' => true,
             'array' => false,
@@ -935,7 +996,7 @@ protected function dropDocumentField(string $collection, string $field): void
      * Mirrors Database::getJunctionCollection — the junction is named after
      * the parent/child sequence pair.
      */
-    protected function resolveJunctionCollection(string $collection, string $relatedCollection, string $side): ?string
+    protected function resolveJunctionCollection(string $collection, string $relatedCollection, RelationSide $side): ?string
     {
         $metadataKey = $this->key(Database::METADATA);
         if (! isset($this->data[$metadataKey])) {
@@ -948,13 +1009,13 @@ protected function resolveJunctionCollection(string $collection, string $related
             return null;
         }
 
-        $collectionSequence = $collectionDoc[1]['_id'] ?? null;
-        $relatedSequence = $relatedDoc[1]['_id'] ?? null;
-        if ($collectionSequence === null || $relatedSequence === null) {
+        $collectionSequence = $collectionDoc[1][Storage::SEQUENCE] ?? null;
+        $relatedSequence = $relatedDoc[1][Storage::SEQUENCE] ?? null;
+        if (! \is_scalar($collectionSequence) || ! \is_scalar($relatedSequence)) {
             return null;
         }
 
-        return $side === Database::RELATION_SIDE_PARENT
+        return $side === RelationSide::Parent
             ? '_'.$collectionSequence.'_'.$relatedSequence
             : '_'.$relatedSequence.'_'.$collectionSequence;
     }
@@ -995,15 +1056,21 @@ public function renameIndex(string $collection, string $old, string $new): bool
         return true;
     }
 
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
         $key = $this->key($collection);
         if (! isset($this->data[$key])) {
             throw new NotFoundException('Collection not found');
         }
 
+        $id = $index->key;
+        $type = $index->type->value;
+        $attributes = $index->attributes;
+        $lengths = $index->lengths;
+        $orders = $index->getAttribute('orders', []);
+
         $hashTable = [];
-        if ($type === Database::INDEX_UNIQUE && ! empty($attributes)) {
+        if ($type === IndexType::Unique->value && ! empty($attributes)) {
             // MariaDB rejects CREATE UNIQUE INDEX with errno 1062 when existing
             // rows contain duplicates; Database::createIndex catches the resulting
             // DuplicateException and treats it as an "orphan index" (the metadata
@@ -1022,7 +1089,7 @@ public function createIndex(string $collection, string $id, string $type, array
                     continue;
                 }
                 if ($this->sharedTables) {
-                    \array_unshift($signature, $row['_tenant'] ?? null);
+                    \array_unshift($signature, $row[Storage::TENANT] ?? null);
                 }
                 $hash = \serialize($signature);
                 if (isset($hashTable[$hash])) {
@@ -1039,13 +1106,13 @@ public function createIndex(string $collection, string $id, string $type, array
             'lengths' => $lengths,
             'orders' => $orders,
         ];
-        if ($type === Database::INDEX_UNIQUE && ! empty($attributes)) {
+        if ($type === IndexType::Unique->value && ! empty($attributes)) {
             $this->uniqueIndexHashes[$key][$id] = $hashTable;
         }
 
         $this->journal(function () use ($key, $id, $type): void {
             unset($this->data[$key]['indexes'][$id]);
-            if ($type === Database::INDEX_UNIQUE) {
+            if ($type === IndexType::Unique->value) {
                 unset($this->uniqueIndexHashes[$key][$id]);
             }
         });
@@ -1113,12 +1180,11 @@ private function getSelectAttributes(array $queries): array
     {
         $selected = [];
         foreach ($queries as $query) {
-            if (! $query instanceof Query) {
-                continue;
-            }
-            if ($query->getMethod() === Query::TYPE_SELECT) {
+            if ($query->getMethod() === Method::Select) {
                 foreach ($query->getValues() as $value) {
-                    $selected[] = (string) $value;
+                    if (\is_string($value)) {
+                        $selected[] = $value;
+                    }
                 }
             }
         }
@@ -1168,7 +1234,8 @@ public function createDocument(Document $collection, Document $document): Docume
                 // Mirrors MariaDB's `INSERT IGNORE` — duplicate primary key is
                 // silently dropped and the existing row's sequence is returned.
                 $existing = $this->data[$key]['documents'][$docKey];
-                $document['$sequence'] = (string) $existing['_id'];
+                $existingId = $existing[Storage::SEQUENCE] ?? '';
+                $document[Document::SEQUENCE] = \is_scalar($existingId) ? (string) $existingId : '';
 
                 return $document;
             }
@@ -1185,22 +1252,24 @@ public function createDocument(Document $collection, Document $document): Docume
             throw $e;
         }
 
-        $sequenceBefore = $this->data[$key]['sequence'];
+        $entry = &$this->data[$key];
+        $sequenceBefore = $entry['sequence'];
         $sequence = $document->getSequence();
         if (empty($sequence)) {
-            $this->data[$key]['sequence']++;
-            $sequence = $this->data[$key]['sequence'];
+            $entry['sequence']++;
+            $sequence = $entry['sequence'];
         } else {
             $sequence = (int) $sequence;
-            if ($sequence > $this->data[$key]['sequence']) {
-                $this->data[$key]['sequence'] = $sequence;
+            if ($sequence > $entry['sequence']) {
+                $entry['sequence'] = $sequence;
             }
         }
 
         $row = $this->documentToRow($document);
-        $row['_id'] = $sequence;
+        $row[Storage::SEQUENCE] = $sequence;
 
-        $this->data[$key]['documents'][$docKey] = $row;
+        $entry['documents'][$docKey] = $row;
+        unset($entry);
         $this->journal(function () use ($key, $docKey, $sequenceBefore): void {
             unset($this->data[$key]['documents'][$docKey]);
             $this->data[$key]['sequence'] = $sequenceBefore;
@@ -1212,13 +1281,27 @@ public function createDocument(Document $collection, Document $document): Docume
 
         $this->writePermissions($key, $document);
 
-        $document['$sequence'] = (string) $sequence;
+        $document[Document::SEQUENCE] = (string) $sequence;
 
         return $document;
     }
 
     public function createDocuments(Document $collection, array $documents): array
     {
+        // Mirror SQL's batch-level sequence consistency check: every document
+        // in a batch must either set $sequence or omit it. SQL adapters reject
+        // mixed batches up front; Memory must match so application code that
+        // catches the resulting DatabaseException behaves the same.
+        $hasSequence = null;
+        foreach ($documents as $document) {
+            $sequenceSet = ! empty($document->getSequence());
+            if ($hasSequence === null) {
+                $hasSequence = $sequenceSet;
+            } elseif ($hasSequence !== $sequenceSet) {
+                throw new DatabaseException('All documents must have an sequence if one is set');
+            }
+        }
+
         $created = [];
         foreach ($documents as $document) {
             $created[] = $this->createDocument($collection, $document);
@@ -1269,38 +1352,45 @@ public function updateDocument(Document $collection, string $id, Document $docum
         $oldSignatures = $this->rowUniqueSignatures($key, $existing);
         $this->checkUniqueSignatures($key, $newSignatures, $oldKey);
 
-        $row['_id'] = $existing['_id'];
-        if ($this->sharedTables && \array_key_exists('_tenant', $existing)) {
+        $row[Storage::SEQUENCE] = $existing[Storage::SEQUENCE];
+        if ($this->sharedTables && \array_key_exists(Storage::TENANT, $existing)) {
             // Preserve the row's stored tenant — MariaDB's UPDATE statements
             // never rewrite `_tenant` and tests rely on the original tenant
             // (e.g. the metadata NULL-tenant rows) surviving an update.
-            $row['_tenant'] = $existing['_tenant'];
+            $row[Storage::TENANT] = $existing[Storage::TENANT];
         }
 
+        $tenantValue = $existing[Storage::TENANT] ?? $this->getTenant();
         $newKey = $this->sharedTables
-            ? ($existing['_tenant'] ?? $this->getTenant()).'|'.\strtolower($newId)
+            ? (\is_scalar($tenantValue) ? (string) $tenantValue : '').'|'.\strtolower($newId)
             : \strtolower($newId);
 
-        $oldKeyHadRow = isset($this->data[$key]['documents'][$oldKey]);
-        $previousAtNewKey = $this->data[$key]['documents'][$newKey] ?? null;
+        $entry = &$this->data[$key];
+        $oldKeyHadRow = isset($entry['documents'][$oldKey]);
+        $previousAtNewKey = $entry['documents'][$newKey] ?? null;
 
         if ($newId !== $id || $newKey !== $oldKey) {
-            unset($this->data[$key]['documents'][$oldKey]);
+            unset($entry['documents'][$oldKey]);
         }
-        $this->data[$key]['documents'][$newKey] = $row;
+        $entry['documents'][$newKey] = $row;
+        unset($entry);
 
         $this->journal(function () use ($key, $oldKey, $newKey, $existing, $oldKeyHadRow, $previousAtNewKey): void {
+            if (! isset($this->data[$key])) {
+                return;
+            }
+            $entry = &$this->data[$key];
             if ($oldKey !== $newKey) {
                 if ($previousAtNewKey === null) {
-                    unset($this->data[$key]['documents'][$newKey]);
+                    unset($entry['documents'][$newKey]);
                 } else {
-                    $this->data[$key]['documents'][$newKey] = $previousAtNewKey;
+                    $entry['documents'][$newKey] = $previousAtNewKey;
                 }
                 if ($oldKeyHadRow) {
-                    $this->data[$key]['documents'][$oldKey] = $existing;
+                    $entry['documents'][$oldKey] = $existing;
                 }
             } else {
-                $this->data[$key]['documents'][$oldKey] = $existing;
+                $entry['documents'][$oldKey] = $existing;
             }
         });
 
@@ -1380,7 +1470,7 @@ public function updateDocuments(Document $collection, Document $updates, array $
         $attrs = $updates->getAttributes();
         $hasCreatedAt = ! empty($updates->getCreatedAt());
         $hasUpdatedAt = ! empty($updates->getUpdatedAt());
-        $hasPermissions = $updates->offsetExists('$permissions');
+        $hasPermissions = $updates->offsetExists(Document::PERMISSIONS);
         if (empty($attrs) && ! $hasCreatedAt && ! $hasUpdatedAt && ! $hasPermissions) {
             return 0;
         }
@@ -1407,7 +1497,7 @@ public function updateDocuments(Document $collection, Document $updates, array $
                 ? new Document(\array_merge(
                     $this->rowToDocument($existingRow),
                     $resolvedAttrs,
-                    ['$id' => $uid]
+                    [Document::ID => $uid]
                 ))
                 : null;
 
@@ -1468,13 +1558,13 @@ public function updateDocuments(Document $collection, Document $updates, array $
             }
 
             if ($hasCreatedAt) {
-                $row['_createdAt'] = $updates->getCreatedAt();
+                $row[Storage::CREATED_AT] = $updates->getCreatedAt();
             }
             if ($hasUpdatedAt) {
-                $row['_updatedAt'] = $updates->getUpdatedAt();
+                $row[Storage::UPDATED_AT] = $updates->getUpdatedAt();
             }
             if ($hasPermissions) {
-                $row['_permissions'] = $updates->getPermissions();
+                $row[Storage::PERMISSIONS] = $updates->getPermissions();
             }
             unset($row);
 
@@ -1484,9 +1574,9 @@ public function updateDocuments(Document $collection, Document $updates, array $
 
             if ($hasPermissions) {
                 $this->removePermissionsForDocument($key, $uid, $tenant, $this->sharedTables);
-                foreach (Database::PERMISSIONS as $type) {
+                foreach ([PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete] as $type) {
                     foreach ($updates->getPermissionsByType($type) as $permission) {
-                        $this->addPermissionEntry($key, $uid, (string) $type, (string) $permission, $tenant);
+                        $this->addPermissionEntry($key, $uid, $type->value, (string) $permission, $tenant);
                     }
                 }
             }
@@ -1507,11 +1597,6 @@ public function updateDocuments(Document $collection, Document $updates, array $
         return \count($prepared);
     }
 
-    public function upsertDocuments(Document $collection, string $attribute, array $changes): array
-    {
-        throw new DatabaseException('Upsert is not implemented in the Memory adapter');
-    }
-
     public function getSequences(string $collection, array $documents): array
     {
         $key = $this->key($collection);
@@ -1527,7 +1612,8 @@ public function getSequences(string $collection, array $documents): array
             // — the lookup must use each document's own tenant, not the adapter's current tenant.
             $existing = $this->data[$key]['documents'][$this->documentKey($doc->getId(), $doc->getTenant())] ?? null;
             if ($existing !== null) {
-                $documents[$index]->setAttribute('$sequence', (string) $existing['_id']);
+                $existingId = $existing[Storage::SEQUENCE] ?? '';
+                $documents[$index]->setAttribute(Document::SEQUENCE, \is_scalar($existingId) ? (string) $existingId : '');
             }
         }
 
@@ -1591,11 +1677,13 @@ public function deleteDocuments(string $collection, array $sequences, array $per
             // With sharedTables the row map is keyed by "tenant|uid" so sequence
             // collisions across tenants are possible. Skip rows that don't belong
             // to the current tenant so we never delete another tenant's data.
-            if ($this->sharedTables && ($row['_tenant'] ?? null) !== $this->getTenant()) {
+            if ($this->sharedTables && ($row[Storage::TENANT] ?? null) !== $this->getTenant()) {
                 continue;
             }
-            if (isset($seqSet[(string) ($row['_id'] ?? '')])) {
-                $deletedIds[(string) ($row['_uid'] ?? $docKey)] = true;
+            $rowId = $row[Storage::SEQUENCE] ?? '';
+            $rowUid = $row[Storage::UID] ?? $docKey;
+            if (isset($seqSet[\is_scalar($rowId) ? (string) $rowId : ''])) {
+                $deletedIds[\is_scalar($rowUid) ? (string) $rowUid : $docKey] = true;
                 $oldSignatures = $this->rowUniqueSignatures($key, $row);
                 unset($this->data[$key]['documents'][$docKey]);
                 $this->journal(function () use ($key, $docKey, $row): void {
@@ -1633,14 +1721,14 @@ public function deleteDocuments(string $collection, array $sequences, array $per
         return $count;
     }
 
-    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array
     {
         $key = $this->key($collection->getId());
         if (! isset($this->data[$key])) {
             throw new NotFoundException('Collection not found');
         }
 
-        $rows = $this->fusedFilter($key, $collection->getId(), $queries, $forPermission);
+        $rows = $this->fusedFilter($key, $collection->getId(), $queries, $forPermission->value);
         $rows = $this->applyOrdering($rows, $orderAttributes, $orderTypes, $cursorDirection);
         $rows = $this->applyCursor($rows, $orderAttributes, $orderTypes, $cursor, $cursorDirection);
 
@@ -1657,7 +1745,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             $results[] = new Document($this->rowToDocument($row, $selections, $key));
         }
 
-        if ($cursorDirection === Database::CURSOR_BEFORE) {
+        if ($cursorDirection === CursorDirection::Before) {
             $results = \array_reverse($results);
         }
 
@@ -1671,7 +1759,7 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
             throw new NotFoundException('Collection not found');
         }
 
-        $rows = $this->fusedFilter($key, $collection->getId(), $queries, Database::PERMISSION_READ);
+        $rows = $this->fusedFilter($key, $collection->getId(), $queries, PermissionType::Read->value);
 
         if (! is_null($max)) {
             // MariaDB applies LIMIT :max inside the COUNT subquery — LIMIT 0
@@ -1689,7 +1777,7 @@ public function sum(Document $collection, string $attribute, array $queries = []
             throw new NotFoundException('Collection not found');
         }
 
-        $rows = $this->fusedFilter($key, $collection->getId(), $queries, Database::PERMISSION_READ);
+        $rows = $this->fusedFilter($key, $collection->getId(), $queries, PermissionType::Read->value);
 
         if (! is_null($max)) {
             $rows = \array_slice($rows, 0, $max);
@@ -1699,19 +1787,20 @@ public function sum(Document $collection, string $attribute, array $queries = []
         $isFloat = false;
         $column = $this->filter($attribute);
         foreach ($rows as $row) {
-            if (! \array_key_exists($column, $row) || $row[$column] === null) {
+            $value = $row[$column] ?? null;
+            if ($value === null || ! \is_numeric($value)) {
                 continue;
             }
-            if (\is_float($row[$column])) {
+            if (\is_float($value)) {
                 $isFloat = true;
             }
-            $sum += $row[$column];
+            $sum += $value;
         }
 
         return $isFloat ? (float) $sum : (int) $sum;
     }
 
-    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value, string $updatedAt, int|float|null $min = null, int|float|null $max = null): bool
+    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float|string $value, string $updatedAt, int|float|string|null $min = null, int|float|string|null $max = null): bool
     {
         $key = $this->key($collection);
         $docKey = $this->documentKey($id);
@@ -1721,9 +1810,10 @@ public function increaseDocumentAttribute(string $collection, string $id, string
 
         $column = $this->filter($attribute);
         $previousValue = $this->data[$key]['documents'][$docKey][$column] ?? null;
-        $previousUpdatedAt = $this->data[$key]['documents'][$docKey]['_updatedAt'] ?? null;
+        $previousUpdatedAt = $this->data[$key]['documents'][$docKey][Storage::UPDATED_AT] ?? null;
         $current = $previousValue ?? 0;
-        $current = is_numeric($current) ? $current + 0 : 0;
+        $exact = (\is_int($current) || (\is_string($current) && BigInt::isIntegerString($current)))
+            && (\is_int($value) || (\is_string($value) && BigInt::isIntegerString($value)));
 
         // MariaDB encodes the bound check as part of the WHERE clause against
         // the current column value (`attr <= :max` / `attr >= :min`); when the
@@ -1731,27 +1821,47 @@ public function increaseDocumentAttribute(string $collection, string $id, string
         // still returns true. Mirror that — silent no-op on bound violation.
         // The Database layer pre-subtracts $value from $max (and adds it to
         // $min), so the comparison stays against the pre-update value.
-        if (! is_null($min) && $current < $min) {
-            return true;
-        }
-        if (! is_null($max) && $current > $max) {
-            return true;
+        if ($exact) {
+            $current = BigInt::toNative($current);
+            $value = BigInt::toNative($value);
+            if (! is_null($min) && BigInt::compare($current, $min) < 0) {
+                return true;
+            }
+            if (! is_null($max) && BigInt::compare($current, $max) > 0) {
+                return true;
+            }
+            $result = BigInt::add($current, $value);
+        } else {
+            $current = $this->numericValue($current, 0) ?? 0;
+            $value = $this->numericValue($value, 0) ?? 0;
+            if (! is_null($min) && $current < $min) {
+                return true;
+            }
+            if (! is_null($max) && $current > $max) {
+                return true;
+            }
+            $result = $current + $value;
         }
 
-        $this->data[$key]['documents'][$docKey][$column] = $current + $value;
-        $this->data[$key]['documents'][$docKey]['_updatedAt'] = $updatedAt;
+        $this->data[$key]['documents'][$docKey][$column] = $result;
+        $this->data[$key]['documents'][$docKey][Storage::UPDATED_AT] = $updatedAt;
 
         $this->journal(function () use ($key, $docKey, $column, $previousValue, $previousUpdatedAt): void {
+            if (! isset($this->data[$key]['documents'][$docKey])) {
+                return;
+            }
+            $row = &$this->data[$key]['documents'][$docKey];
             if ($previousValue === null) {
-                unset($this->data[$key]['documents'][$docKey][$column]);
+                unset($row[$column]);
             } else {
-                $this->data[$key]['documents'][$docKey][$column] = $previousValue;
+                $row[$column] = $previousValue;
             }
             if ($previousUpdatedAt === null) {
-                unset($this->data[$key]['documents'][$docKey]['_updatedAt']);
+                unset($row[Storage::UPDATED_AT]);
             } else {
-                $this->data[$key]['documents'][$docKey]['_updatedAt'] = $previousUpdatedAt;
+                $row[Storage::UPDATED_AT] = $previousUpdatedAt;
             }
+            unset($row);
         });
 
         return true;
@@ -1817,17 +1927,7 @@ public function getMinDateTime(): \DateTime
 
     public function getIdAttributeType(): string
     {
-        return Database::VAR_INTEGER;
-    }
-
-    public function getSupportForSchemas(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForAttributes(): bool
-    {
-        return $this->supportForAttributes;
+        return ColumnType::Integer->value;
     }
 
     public function setSupportForAttributes(bool $support): bool
@@ -1837,203 +1937,18 @@ public function setSupportForAttributes(bool $support): bool
         return $this->supportForAttributes;
     }
 
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForIndex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForIndexArray(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCastIndexArray(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUniqueIndex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForFulltextIndex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCasting(): bool
-    {
-        // Memory stores native PHP types where possible but JSON-encodes array
-        // attributes on write. Returning true asks the Database layer's
-        // `casting` step to JSON-decode array columns and coerce scalar types
-        // — same behaviour as the SQL adapters.
-        return true;
-    }
-
-    public function getSupportForQueryContains(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForTimeouts(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForRelationships(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpdateLock(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForBatchOperations(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForAttributeResizing(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForGetConnectionId(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUpserts(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForVectors(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCaching(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForReconnection(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForHostname(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForObject(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForObjectIndexes(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForOperators(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForMultipleFulltextIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForIdenticalIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForOrderRandom(): bool
-    {
-        return true;
-    }
-
     public function getCountOfAttributes(Document $collection): int
     {
-        return \count($collection->getAttribute('attributes', [])) + $this->getCountOfDefaultAttributes();
+        $attributes = $collection->getAttribute('attributes', []);
+
+        return (\is_array($attributes) ? \count($attributes) : 0) + $this->getCountOfDefaultAttributes();
     }
 
     public function getCountOfIndexes(Document $collection): int
     {
-        return \count($collection->getAttribute('indexes', [])) + $this->getCountOfDefaultIndexes();
+        $indexes = $collection->getAttribute('indexes', []);
+
+        return (\is_array($indexes) ? \count($indexes) : 0) + $this->getCountOfDefaultIndexes();
     }
 
     public function getCountOfDefaultAttributes(): int
@@ -2066,26 +1981,11 @@ protected function getAttributeProjection(array $selections, string $prefix): mi
         return $selections;
     }
 
-    public function getConnectionId(): string
-    {
-        return '0';
-    }
-
     public function getInternalIndexesKeys(): array
     {
         return [];
     }
 
-    public function getSchemaAttributes(string $collection): array
-    {
-        return [];
-    }
-
-    public function getSchemaIndexes(string $collection): array
-    {
-        return [];
-    }
-
     public function getTenantQuery(string $collection, string $alias = ''): string
     {
         return '';
@@ -2101,31 +2001,6 @@ protected function quote(string $string): string
         return '"'.$string.'"';
     }
 
-    public function decodePoint(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Memory adapter');
-    }
-
-    public function decodeLinestring(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Memory adapter');
-    }
-
-    public function decodePolygon(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Memory adapter');
-    }
-
-    public function castingBefore(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
-
-    public function castingAfter(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
-
     /**
      * Get max BIGINT limit
      *
@@ -2136,31 +2011,6 @@ public function getLimitForBigInt(): int
         return Database::MAX_BIG_INT;
     }
 
-    public function getSupportForInternalCasting(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUTCCasting(): bool
-    {
-        return false;
-    }
-
-    public function setUTCDatetime(string $value): mixed
-    {
-        return $value;
-    }
-
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
-    }
-
     public function getSupportNonUtfCharacters(): bool
     {
         // Memory is a pass-through PHP array, so it does NOT actively reject
@@ -2169,35 +2019,6 @@ public function getSupportNonUtfCharacters(): bool
         return false;
     }
 
-    public function getSupportForTrigramIndex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForPCRERegex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForPOSIXRegex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForTransactionRetries(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForNestedTransactions(): bool
-    {
-        return true;
-    }
-
-    // -----------------------------------------------------------------
-    // Internal helpers
-    // -----------------------------------------------------------------
-
     /**
      * @return array<string, mixed>
      */
@@ -2211,15 +2032,15 @@ protected function documentToRow(Document $document): array
             $row[$this->filter($attribute)] = $value;
         }
 
-        $row['_uid'] = $document->getId();
-        $row['_createdAt'] = $document->getCreatedAt();
-        $row['_updatedAt'] = $document->getUpdatedAt();
-        $row['_permissions'] = $document->getPermissions();
+        $row[Storage::UID] = $document->getId();
+        $row[Storage::CREATED_AT] = $document->getCreatedAt();
+        $row[Storage::UPDATED_AT] = $document->getUpdatedAt();
+        $row[Storage::PERMISSIONS] = $document->getPermissions();
         if ($this->sharedTables) {
             // Mirror MariaDB: the row's `_tenant` follows the document's own
             // tenant — that matters in tenantPerDocument mode where the
             // adapter's current tenant is null but each document is tagged.
-            $row['_tenant'] = $document->getTenant() ?? $this->getTenant();
+            $row[Storage::TENANT] = $document->getTenant() ?? $this->getTenant();
         }
 
         return $row;
@@ -2251,23 +2072,23 @@ protected function rowToDocument(array $row, ?array $selections = null, ?string
         $document = [];
         foreach ($row as $key => $value) {
             switch ($key) {
-                case '_id':
-                    $document['$sequence'] = (string) $value;
+                case Storage::SEQUENCE:
+                    $document[Document::SEQUENCE] = \is_scalar($value) ? (string) $value : '';
                     break;
-                case '_uid':
-                    $document['$id'] = $value;
+                case Storage::UID:
+                    $document[Document::ID] = $value;
                     break;
-                case '_tenant':
-                    $document['$tenant'] = $value;
+                case Storage::TENANT:
+                    $document[Document::TENANT] = $value;
                     break;
-                case '_createdAt':
-                    $document['$createdAt'] = $value;
+                case Storage::CREATED_AT:
+                    $document[Document::CREATED_AT] = $value;
                     break;
-                case '_updatedAt':
-                    $document['$updatedAt'] = $value;
+                case Storage::UPDATED_AT:
+                    $document[Document::UPDATED_AT] = $value;
                     break;
-                case '_permissions':
-                    $document['$permissions'] = $value ?? [];
+                case Storage::PERMISSIONS:
+                    $document[Document::PERMISSIONS] = $value ?? [];
                     break;
                 default:
                     if ($allowed !== null && ! isset($allowed[$key])) {
@@ -2281,7 +2102,7 @@ protected function rowToDocument(array $row, ?array $selections = null, ?string
         // MariaDB selecting a `DEFAULT NULL` column even when no row has set it.
         if ($storageKey !== null && isset($this->data[$storageKey]['attributes'])) {
             foreach ($this->data[$storageKey]['attributes'] as $attributeId => $definition) {
-                if (($definition['type'] ?? null) !== Database::VAR_RELATIONSHIP) {
+                if (($definition['type'] ?? null) !== ColumnType::Relationship->value) {
                     continue;
                 }
                 if ($allowed !== null && ! isset($allowed[$attributeId])) {
@@ -2304,7 +2125,7 @@ protected function extractSelections(array $queries): array
     {
         $selections = [];
         foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
+            if ($query->getMethod() === Method::Select) {
                 foreach ($query->getValues() as $value) {
                     if (\is_string($value)) {
                         $selections[] = $value;
@@ -2320,9 +2141,9 @@ protected function writePermissions(string $key, Document $document): void
     {
         $uid = $document->getId();
         $tenant = $document->getTenant() ?? $this->getTenant();
-        foreach (Database::PERMISSIONS as $type) {
+        foreach ([PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete] as $type) {
             foreach ($document->getPermissionsByType($type) as $permission) {
-                $this->addPermissionEntry($key, $uid, $type, $permission, $tenant);
+                $this->addPermissionEntry($key, $uid, $type->value, (string) $permission, $tenant);
             }
         }
     }
@@ -2480,15 +2301,18 @@ protected function rowUniqueSignatures(string $key, array $row): array
     {
         $result = [];
         foreach ($this->data[$key]['indexes'] ?? [] as $indexId => $index) {
-            if (($index['type'] ?? '') !== Database::INDEX_UNIQUE) {
+            if (($index['type'] ?? '') !== IndexType::Unique->value) {
                 continue;
             }
             $attributes = $index['attributes'] ?? [];
-            if (empty($attributes)) {
+            if (! \is_array($attributes) || empty($attributes)) {
                 continue;
             }
             $signature = [];
             foreach ($attributes as $attribute) {
+                if (! \is_string($attribute)) {
+                    continue;
+                }
                 $signature[] = $this->normalizeIndexValue($this->resolveAttributeValue($row, $attribute));
             }
             if (\in_array(null, $signature, true)) {
@@ -2499,7 +2323,7 @@ protected function rowUniqueSignatures(string $key, array $row): array
             // tenant into the hash key so two tenants holding the same
             // value do not collide.
             if ($this->sharedTables) {
-                \array_unshift($signature, $row['_tenant'] ?? null);
+                \array_unshift($signature, $row[Storage::TENANT] ?? null);
             }
             $result[$indexId] = \serialize($signature);
         }
@@ -2516,24 +2340,30 @@ protected function documentUniqueSignatures(string $key, Document $document): ar
     {
         $result = [];
         foreach ($this->data[$key]['indexes'] ?? [] as $indexId => $index) {
-            if (($index['type'] ?? '') !== Database::INDEX_UNIQUE) {
+            if (($index['type'] ?? '') !== IndexType::Unique->value) {
                 continue;
             }
             $attributes = $index['attributes'] ?? [];
-            if (empty($attributes)) {
+            if (! \is_array($attributes) || empty($attributes)) {
                 continue;
             }
             $signature = [];
             foreach ($attributes as $attribute) {
+                if (! \is_string($attribute)) {
+                    continue;
+                }
                 $signature[] = $this->normalizeIndexValue($this->resolveDocumentValue($document, $attribute));
             }
             if (\in_array(null, $signature, true)) {
                 continue;
             }
             // Match rowUniqueSignatures: under shared tables, scope by the
-            // current adapter tenant so cross-tenant collisions never throw.
+            // tenant the row will actually be stored under. documentToRow
+            // writes `_tenant = $document->getTenant() ?? $this->getTenant()`,
+            // so the read- and write-side signatures must agree on that
+            // fallback or duplicate detection skips across tenants.
             if ($this->sharedTables) {
-                \array_unshift($signature, $this->getTenant());
+                \array_unshift($signature, $document->getTenant() ?? $this->getTenant());
             }
             $result[$indexId] = \serialize($signature);
         }
@@ -2561,7 +2391,7 @@ protected function fusedFilter(string $key, string $collectionId, array $queries
         $effectiveQueries = [];
         foreach ($queries as $query) {
             $method = $query->getMethod();
-            if (\in_array($method, [Query::TYPE_SELECT, Query::TYPE_ORDER_ASC, Query::TYPE_ORDER_DESC, Query::TYPE_ORDER_RANDOM, Query::TYPE_LIMIT, Query::TYPE_OFFSET, Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE], true)) {
+            if (\in_array($method, [Method::Select, Method::OrderAsc, Method::OrderDesc, Method::OrderRandom, Method::Limit, Method::Offset, Method::CursorAfter, Method::CursorBefore], true)) {
                 continue;
             }
             $effectiveQueries[] = $query;
@@ -2576,7 +2406,7 @@ protected function fusedFilter(string $key, string $collectionId, array $queries
         $output = [];
         foreach ($documents as $row) {
             if ($tenantCheck) {
-                $rowTenant = $row['_tenant'] ?? null;
+                $rowTenant = $row[Storage::TENANT] ?? null;
                 if ($allowNullTenant && $rowTenant === null) {
                     // visible
                 } elseif ($rowTenant !== $tenant) {
@@ -2584,7 +2414,8 @@ protected function fusedFilter(string $key, string $collectionId, array $queries
                 }
             }
 
-            if ($allowSet !== null && ! isset($allowSet[$row['_uid'] ?? ''])) {
+            $rowUid = $row[Storage::UID] ?? '';
+            if ($allowSet !== null && (! \is_string($rowUid) || ! isset($allowSet[$rowUid]))) {
                 continue;
             }
 
@@ -2612,7 +2443,7 @@ protected function matches(array $row, Query $query): bool
     {
         $method = $query->getMethod();
 
-        if ($method === Query::TYPE_AND) {
+        if ($method === Method::And) {
             foreach ($query->getValues() as $sub) {
                 if (! ($sub instanceof Query) || ! $this->matches($row, $sub)) {
                     return false;
@@ -2622,7 +2453,7 @@ protected function matches(array $row, Query $query): bool
             return true;
         }
 
-        if ($method === Query::TYPE_OR) {
+        if ($method === Method::Or) {
             foreach ($query->getValues() as $sub) {
                 if ($sub instanceof Query && $this->matches($row, $sub)) {
                     return true;
@@ -2642,8 +2473,17 @@ protected function matches(array $row, Query $query): bool
         }
 
         switch ($method) {
-            case Query::TYPE_EQUAL:
+            case Method::Equal:
+                // SQL three-valued logic: `col = NULL` is unknown — null rows
+                // never match an explicit equality, even when callers pass
+                // `[null]`. Use `Query::isNull()` for that case.
+                if ($value === null) {
+                    return false;
+                }
                 foreach ($queryValues as $candidate) {
+                    if ($candidate === null) {
+                        continue;
+                    }
                     if ($this->looseEquals($value, $candidate)) {
                         return true;
                     }
@@ -2651,12 +2491,19 @@ protected function matches(array $row, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_EQUAL:
+            case Method::NotEqual:
                 // SQL: NULL != x evaluates to NULL (i.e. excluded), not true.
                 if ($value === null) {
                     return false;
                 }
                 foreach ($queryValues as $candidate) {
+                    // SQL three-valued logic: `col NOT IN (..., NULL, ...)`
+                    // is unknown for every row — exclude. Mirrors the null-
+                    // candidate handling in Method::Equal above. Use
+                    // `Query::isNotNull()` for the explicit not-null intent.
+                    if ($candidate === null) {
+                        return false;
+                    }
                     if ($this->looseEquals($value, $candidate)) {
                         return false;
                     }
@@ -2664,28 +2511,28 @@ protected function matches(array $row, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_LESSER:
+            case Method::LessThan:
                 return $value !== null && $value < $queryValues[0];
 
-            case Query::TYPE_LESSER_EQUAL:
+            case Method::LessThanEqual:
                 return $value !== null && $value <= $queryValues[0];
 
-            case Query::TYPE_GREATER:
+            case Method::GreaterThan:
                 return $value !== null && $value > $queryValues[0];
 
-            case Query::TYPE_GREATER_EQUAL:
+            case Method::GreaterThanEqual:
                 return $value !== null && $value >= $queryValues[0];
 
-            case Query::TYPE_IS_NULL:
+            case Method::IsNull:
                 return $value === null;
 
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNotNull:
                 return $value !== null;
 
-            case Query::TYPE_BETWEEN:
+            case Method::Between:
                 return $value !== null && $value >= $queryValues[0] && $value <= $queryValues[1];
 
-            case Query::TYPE_NOT_BETWEEN:
+            case Method::NotBetween:
                 // SQL: NULL NOT BETWEEN x AND y evaluates to NULL (excluded).
                 if ($value === null) {
                     return false;
@@ -2693,27 +2540,27 @@ protected function matches(array $row, Query $query): bool
 
                 return $value < $queryValues[0] || $value > $queryValues[1];
 
-            case Query::TYPE_STARTS_WITH:
+            case Method::StartsWith:
                 return \is_string($value) && \is_string($queryValues[0]) && \str_starts_with($value, $queryValues[0]);
 
-            case Query::TYPE_NOT_STARTS_WITH:
+            case Method::NotStartsWith:
                 if ($value === null) {
                     return false;
                 }
 
                 return ! \is_string($value) || ! \is_string($queryValues[0]) || ! \str_starts_with($value, $queryValues[0]);
 
-            case Query::TYPE_ENDS_WITH:
+            case Method::EndsWith:
                 return \is_string($value) && \is_string($queryValues[0]) && \str_ends_with($value, $queryValues[0]);
 
-            case Query::TYPE_NOT_ENDS_WITH:
+            case Method::NotEndsWith:
                 if ($value === null) {
                     return false;
                 }
 
                 return ! \is_string($value) || ! \is_string($queryValues[0]) || ! \str_ends_with($value, $queryValues[0]);
 
-            case Query::TYPE_CONTAINS:
+            case Method::Contains:
                 $haystack = $this->decodeArrayValue($value);
                 if ($haystack === null && \is_string($value)) {
                     // Mirror MariaDB's default case-insensitive collation for
@@ -2740,16 +2587,16 @@ protected function matches(array $row, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_CONTAINS:
+            case Method::NotContains:
                 // SQL: NULL NOT LIKE '%x%' / JSON_CONTAINS(NULL, ...) evaluates
                 // to NULL — null-valued rows are excluded, not matched.
                 if ($value === null) {
                     return false;
                 }
 
-                return ! $this->matches($row, new Query(Query::TYPE_CONTAINS, $query->getAttribute(), $queryValues));
+                return ! $this->matches($row, new Query(Method::Contains, $query->getAttribute(), $queryValues));
 
-            case Query::TYPE_CONTAINS_ANY:
+            case Method::ContainsAny:
                 // containsAny behaves like contains: array attributes match
                 // any of the supplied needles, scalar string attributes fall
                 // back to a case-insensitive substring search.
@@ -2776,7 +2623,7 @@ protected function matches(array $row, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_CONTAINS_ALL:
+            case Method::ContainsAll:
                 $haystack = $this->decodeArrayValue($value);
                 if (! \is_array($haystack)) {
                     return false;
@@ -2796,18 +2643,18 @@ protected function matches(array $row, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_SEARCH:
+            case Method::Search:
                 if (! \is_string($value)) {
                     return false;
                 }
-                $needle = (string) ($queryValues[0] ?? '');
-                if ($needle === '') {
+                $searchNeedle = $queryValues[0] ?? '';
+                if (! \is_string($searchNeedle) || $searchNeedle === '') {
                     return false;
                 }
 
-                return $this->matchesFulltext($value, $needle);
+                return $this->matchesFulltext($value, $searchNeedle);
 
-            case Query::TYPE_NOT_SEARCH:
+            case Method::NotSearch:
                 // SQL: NULL NOT MATCH evaluates to NULL — null rows excluded.
                 if ($value === null) {
                     return false;
@@ -2815,23 +2662,26 @@ protected function matches(array $row, Query $query): bool
                 if (! \is_string($value)) {
                     return true;
                 }
-                $needle = (string) ($queryValues[0] ?? '');
-                if ($needle === '') {
+                $notSearchNeedle = $queryValues[0] ?? '';
+                if (! \is_string($notSearchNeedle) || $notSearchNeedle === '') {
                     return true;
                 }
 
-                return ! $this->matchesFulltext($value, $needle);
+                return ! $this->matchesFulltext($value, $notSearchNeedle);
 
-            case Query::TYPE_REGEX:
+            case Method::Regex:
                 if (! \is_string($value)) {
                     return false;
                 }
-                $pattern = (string) ($queryValues[0] ?? '');
+                $pattern = $queryValues[0] ?? '';
+                if (! \is_string($pattern)) {
+                    return false;
+                }
 
                 return $this->matchesRegex($value, $pattern);
         }
 
-        throw new DatabaseException('Query method not implemented in the Memory adapter: '.$method);
+        throw new DatabaseException('Query method not implemented in the Memory adapter: '.$method->value);
     }
 
     /**
@@ -2913,7 +2763,11 @@ protected function looseEquals(mixed $a, mixed $b): bool
             return true;
         }
         if (\is_numeric($a) && \is_numeric($b)) {
-            return $a + 0 === $b + 0;
+            // Compare numerically with `==` so cross-type pairs like
+            // ("3", "3.0") or (3, 3.0) match the way SQL `WHERE col = '3.0'`
+            // matches an int column holding 3. Strict `===` after `+0`
+            // splits int/float and silently misses parity.
+            return $a == $b;
         }
 
         return false;
@@ -2952,7 +2806,7 @@ protected function matchesObject(mixed $value, Query $query): bool
         $method = $query->getMethod();
 
         switch ($method) {
-            case Query::TYPE_EQUAL:
+            case Method::Equal:
                 if ($haystack === null) {
                     return false;
                 }
@@ -2964,7 +2818,7 @@ protected function matchesObject(mixed $value, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_EQUAL:
+            case Method::NotEqual:
                 // Postgres: NOT (NULL @> x) evaluates to NULL — null/invalid
                 // JSON rows are excluded, mirroring SQL three-valued logic.
                 if ($haystack === null) {
@@ -2978,8 +2832,8 @@ protected function matchesObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
+            case Method::Contains:
+            case Method::ContainsAny:
                 if ($haystack === null) {
                     return false;
                 }
@@ -2991,7 +2845,7 @@ protected function matchesObject(mixed $value, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_CONTAINS_ALL:
+            case Method::ContainsAll:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3003,7 +2857,7 @@ protected function matchesObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_NOT_CONTAINS:
+            case Method::NotContains:
                 // Postgres three-valued logic: NULL field excluded from negation.
                 if ($haystack === null) {
                     return false;
@@ -3016,32 +2870,36 @@ protected function matchesObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_IS_NULL:
+            case Method::IsNull:
                 return $value === null;
 
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNotNull:
                 return $value !== null;
         }
 
-        throw new DatabaseException('Query method '.$method.' not supported for object attributes');
+        throw new DatabaseException('Query method '.$method->value.' not supported for object attributes');
     }
 
-    protected function decodeObjectValue(mixed $value): mixed
+    /**
+     * Return the decoded array if $value is already an array or looks like a
+     * JSON object/array literal; null otherwise. Mirrors decodeArrayValue and
+     * lets matchesObject's callers rely on a single `null === no match` guard
+     * rather than dispatching on raw scalar types.
+     *
+     * @return array<mixed>|null
+     */
+    protected function decodeObjectValue(mixed $value): ?array
     {
-        if ($value === null) {
-            return null;
-        }
         if (\is_array($value)) {
             return $value;
         }
         if (\is_string($value) && $value !== '' && ($value[0] === '{' || $value[0] === '[')) {
             $decoded = \json_decode($value, true);
-            if (\is_array($decoded)) {
-                return $decoded;
-            }
+
+            return \is_array($decoded) ? $decoded : null;
         }
 
-        return $value;
+        return null;
     }
 
     /**
@@ -3201,15 +3059,7 @@ protected function resolveNestedPath(mixed $value, string $path): mixed
 
     protected function mapAttribute(string $attribute): string
     {
-        return match ($attribute) {
-            '$id' => '_uid',
-            '$sequence' => '_id',
-            '$tenant' => '_tenant',
-            '$createdAt' => '_createdAt',
-            '$updatedAt' => '_updatedAt',
-            '$permissions' => '_permissions',
-            default => $this->filter($attribute),
-        };
+        return $this->filter(Storage::column($attribute));
     }
 
     /**
@@ -3259,30 +3109,30 @@ protected function buildPermissionAllowSet(string $key, string $forPermission):
     /**
      * @param  array<array<string, mixed>>  $rows
      * @param  array<string>  $orderAttributes
-     * @param  array<string>  $orderTypes
+     * @param  array<OrderDirection>  $orderTypes
      * @return array<array<string, mixed>>
      */
-    protected function applyOrdering(array $rows, array $orderAttributes, array $orderTypes, string $cursorDirection): array
+    protected function applyOrdering(array $rows, array $orderAttributes, array $orderTypes, CursorDirection $cursorDirection): array
     {
         // Random ordering must short-circuit: a non-deterministic comparator
         // breaks usort's transitivity invariant. Shuffle once and return.
         foreach ($orderTypes as $type) {
-            if ($type === Database::ORDER_RANDOM) {
+            if ($type === OrderDirection::Random) {
                 \shuffle($rows);
 
                 return $rows;
             }
         }
 
-        $reverse = $cursorDirection === Database::CURSOR_BEFORE;
+        $reverse = $cursorDirection === CursorDirection::Before;
 
         if (empty($orderAttributes)) {
             // Mirror MariaDB's clustered-index ordering when no explicit ORDER BY
             // is supplied — sort by the auto-incrementing _id ascending so
             // pagination via limit/offset is stable across calls.
             \usort($rows, function (array $a, array $b) use ($reverse) {
-                $av = $a['_id'] ?? 0;
-                $bv = $b['_id'] ?? 0;
+                $av = $a[Storage::SEQUENCE] ?? 0;
+                $bv = $b[Storage::SEQUENCE] ?? 0;
                 if ($av === $bv) {
                     return 0;
                 }
@@ -3302,11 +3152,11 @@ protected function applyOrdering(array $rows, array $orderAttributes, array $ord
         $directions = [];
         foreach ($orderAttributes as $i => $attribute) {
             $columns[$i] = $this->mapAttribute($attribute);
-            $direction = $orderTypes[$i] ?? Database::ORDER_ASC;
+            $direction = $orderTypes[$i] ?? OrderDirection::Asc;
             if ($reverse) {
-                $direction = $direction === Database::ORDER_ASC ? Database::ORDER_DESC : Database::ORDER_ASC;
+                $direction = $direction === OrderDirection::Asc ? OrderDirection::Desc : OrderDirection::Asc;
             }
-            $directions[$i] = $direction === Database::ORDER_ASC ? 1 : -1;
+            $directions[$i] = $direction === OrderDirection::Asc ? 1 : -1;
         }
 
         $count = \count($rows);
@@ -3350,31 +3200,31 @@ protected function applyOrdering(array $rows, array $orderAttributes, array $ord
     /**
      * @param  array<array<string, mixed>>  $rows
      * @param  array<string>  $orderAttributes
-     * @param  array<string>  $orderTypes
+     * @param  array<OrderDirection>  $orderTypes
      * @param  array<string, mixed>  $cursor
      * @return array<array<string, mixed>>
      */
-    protected function applyCursor(array $rows, array $orderAttributes, array $orderTypes, array $cursor, string $cursorDirection): array
+    protected function applyCursor(array $rows, array $orderAttributes, array $orderTypes, array $cursor, CursorDirection $cursorDirection): array
     {
         if (empty($cursor)) {
             return $rows;
         }
 
         if (empty($orderAttributes)) {
-            $orderAttributes = ['$sequence'];
-            $orderTypes = [Database::ORDER_ASC];
+            $orderAttributes = [Document::SEQUENCE];
+            $orderTypes = [OrderDirection::Asc];
         }
 
-        $reverse = $cursorDirection === Database::CURSOR_BEFORE;
+        $reverse = $cursorDirection === CursorDirection::Before;
         $resolved = [];
         foreach ($orderAttributes as $i => $attribute) {
-            $direction = $orderTypes[$i] ?? Database::ORDER_ASC;
+            $direction = $orderTypes[$i] ?? OrderDirection::Asc;
             if ($reverse) {
-                $direction = $direction === Database::ORDER_ASC ? Database::ORDER_DESC : Database::ORDER_ASC;
+                $direction = $direction === OrderDirection::Asc ? OrderDirection::Desc : OrderDirection::Asc;
             }
             $resolved[] = [
                 'column' => $this->mapAttribute($attribute),
-                'asc' => $direction === Database::ORDER_ASC,
+                'asc' => $direction === OrderDirection::Asc,
                 'ref' => $cursor[$attribute] ?? null,
             ];
         }
@@ -3467,129 +3317,115 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
     {
         $values = $operator->getValues();
         $method = $operator->getMethod();
+        $exact = BigInt::calculateOutsideNative($method, $current ?? 0, $values[0] ?? 1);
+        if ($exact !== null) {
+            $bound = $values[1] ?? null;
+            if ($method === OperatorType::Modulo || ! BigInt::isIntegerValue($bound)) {
+                return $exact;
+            }
+
+            return $this->applyNumericLimit(
+                $current ?? 0,
+                $exact,
+                $bound,
+                \in_array($method, [OperatorType::Increment, OperatorType::Multiply, OperatorType::Power], true)
+            );
+        }
 
         switch ($method) {
-            case Operator::TYPE_INCREMENT:
-                $by = $values[0] ?? 1;
-                $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($max !== null) {
-                    // Compare *remaining headroom* against $by so we never overflow PHP's int
-                    // range. Guard: if the RESULT would exceed the max, leave it unchanged.
-                    // Note: we must NOT short-circuit on `$base >= $max` — a negative $by moves
-                    // the value down, so an already-over-max base can still land within bound
-                    // (e.g. 52 + (-5) = 47 <= 50 must apply).
-                    if (($max - $base) < $by) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                }
+            case OperatorType::Increment:
+                $byInc = $this->numericValue($values[0] ?? null, 1);
+                $maxInc = $this->numericValue($values[1] ?? null, null);
+                $baseInc = \is_numeric($current) ? $current + 0 : 0;
 
-                return $this->preserveNumericType($base, $base + $by);
+                return $this->applyNumericLimit($baseInc, $baseInc + $byInc, $maxInc, true);
 
-            case Operator::TYPE_DECREMENT:
-                $by = $values[0] ?? 1;
-                $min = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($min !== null) {
-                    // Guard: leave unchanged only if the RESULT would go below min. Don't
-                    // short-circuit on `$base <= $min` — a negative $by moves the value up.
-                    if (($base - $min) < $by) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                }
+            case OperatorType::Decrement:
+                $byDec = $this->numericValue($values[0] ?? null, 1);
+                $minDec = $this->numericValue($values[1] ?? null, null);
+                $baseDec = \is_numeric($current) ? $current + 0 : 0;
 
-                return $this->preserveNumericType($base, $base - $by);
+                return $this->applyNumericLimit($baseDec, $baseDec - $byDec, $minDec, false);
 
-            case Operator::TYPE_MULTIPLY:
-                $by = $values[0] ?? 1;
-                $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                $result = $base * $by;
-                if ($max !== null && $result > $max) {
-                    return $this->preserveNumericType($base, $base);
-                }
+            case OperatorType::Multiply:
+                $byMul = $this->numericValue($values[0] ?? null, 1);
+                $maxMul = $this->numericValue($values[1] ?? null, null);
+                $baseMul = \is_numeric($current) ? $current + 0 : 0;
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($baseMul, $baseMul * $byMul, $maxMul, true);
 
-            case Operator::TYPE_DIVIDE:
-                $by = $values[0] ?? 1;
-                $min = $values[1] ?? null;
-                if ($by == 0) {
+            case OperatorType::Divide:
+                $byDiv = $this->numericValue($values[0] ?? null, 1);
+                $minDiv = $this->numericValue($values[1] ?? null, null);
+                if ($byDiv == 0) {
                     return $current;
                 }
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                $result = $base / $by;
-                if ($min !== null && $result < $min) {
-                    return $this->preserveNumericType($base, $base);
-                }
+                $baseDiv = \is_numeric($current) ? $current + 0 : 0;
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($baseDiv, $baseDiv / $byDiv, $minDiv, false);
 
-            case Operator::TYPE_MODULO:
-                $by = $values[0] ?? 1;
-                if ($by == 0) {
+            case OperatorType::Modulo:
+                $byMod = (int) $this->numericValue($values[0] ?? null, 1);
+                if ($byMod == 0) {
                     return $current;
                 }
-                $base = \is_numeric($current) ? (int) $current : 0;
+                $baseMod = \is_numeric($current) ? (int) $current : 0;
 
-                return $base % (int) $by;
+                return $baseMod % $byMod;
 
-            case Operator::TYPE_POWER:
-                $by = $values[0] ?? 1;
-                $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($max !== null) {
-                    // Leave the value unchanged for undefined inputs (0 to a negative power, or a
-                    // negative base to a fractional exponent) — they produce INF/NaN, not a number.
-                    if (($base == 0 && $by < 0) || ($base < 0 && \floor($by) != $by)) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                    $result = $base ** $by;
-                    // A result that overflows (INF) or exceeds the max also leaves the value as-is.
-                    if (!\is_finite($result) || $result > $max) {
-                        return $this->preserveNumericType($base, $base);
+            case OperatorType::Power:
+                $byPow = $this->numericValue($values[0] ?? null, 1) ?? 1;
+                $maxPow = $this->numericValue($values[1] ?? null, null);
+                $basePow = \is_numeric($current) ? $current + 0 : 0;
+                if (($basePow == 0 && $byPow < 0) || ($basePow < 0 && \floor($byPow) != $byPow)) {
+                    if ($maxPow !== null) {
+                        return $basePow;
                     }
 
-                    return $this->preserveNumericType($base, $result);
+                    throw new LimitException('Value out of range');
                 }
 
-                // 0 to a negative power, or a negative base to a fractional exponent, is not a real
-                // number. Fail loudly with a clear exception rather than storing INF/NaN.
-                $result = $base ** $by;
-                if (!\is_finite($result)) {
+                $candidate = $basePow ** $byPow;
+                if (! \is_finite((float) $candidate)) {
+                    if ($maxPow !== null) {
+                        return $basePow;
+                    }
+
                     throw new LimitException('Value out of range');
                 }
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($basePow, $candidate, $maxPow, true);
 
-            case Operator::TYPE_STRING_CONCAT:
-                return ((string) ($current ?? '')).(string) ($values[0] ?? '');
+            case OperatorType::StringConcat:
+                $appendValue = $values[0] ?? '';
 
-            case Operator::TYPE_STRING_REPLACE:
-                $search = (string) ($values[0] ?? '');
-                $replace = (string) ($values[1] ?? '');
+                return $this->stringValue($current).$this->stringValue($appendValue);
+
+            case OperatorType::StringReplace:
+                $search = $this->stringValue($values[0] ?? '');
+                $replace = $this->stringValue($values[1] ?? '');
                 if ($current === null) {
                     return null;
                 }
 
-                return \str_replace($search, $replace, (string) $current);
+                return \str_replace($search, $replace, $this->stringValue($current));
 
-            case Operator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 return ! (bool) $current;
 
-            case Operator::TYPE_ARRAY_APPEND:
+            case OperatorType::ArrayAppend:
                 $list = $this->coerceArray($current);
 
                 return [...$list, ...\array_values($values)];
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayPrepend:
                 $list = $this->coerceArray($current);
 
                 return [...\array_values($values), ...$list];
 
-            case Operator::TYPE_ARRAY_INSERT:
+            case OperatorType::ArrayInsert:
                 $list = $this->coerceArray($current);
-                $index = (int) ($values[0] ?? 0);
+                $index = (int) $this->numericValue($values[0] ?? null, 0);
                 $value = $values[1] ?? null;
                 if ($index < 0) {
                     $index = 0;
@@ -3601,65 +3437,109 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
 
                 return $list;
 
-            case Operator::TYPE_ARRAY_REMOVE:
+            case OperatorType::ArrayRemove:
                 $list = $this->coerceArray($current);
                 $needle = $values[0] ?? null;
 
                 return \array_values(\array_filter($list, fn ($item) => $item !== $needle));
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 $list = $this->coerceArray($current);
 
                 return \array_values(\array_unique($list, SORT_REGULAR));
 
-            case Operator::TYPE_ARRAY_INTERSECT:
+            case OperatorType::ArrayIntersect:
                 $list = $this->coerceArray($current);
                 $other = \array_values($values);
 
                 return \array_values(\array_filter($list, fn ($item) => \in_array($item, $other, false)));
 
-            case Operator::TYPE_ARRAY_DIFF:
+            case OperatorType::ArrayDiff:
                 $list = $this->coerceArray($current);
                 $other = \array_values($values);
 
                 return \array_values(\array_filter($list, fn ($item) => ! \in_array($item, $other, false)));
 
-            case Operator::TYPE_ARRAY_FILTER:
+            case OperatorType::ArrayFilter:
                 $list = $this->coerceArray($current);
-                $condition = (string) ($values[0] ?? '');
+                $condition = $this->stringValue($values[0] ?? '');
                 $compare = $values[1] ?? null;
 
                 return \array_values(\array_filter($list, fn ($item) => $this->matchesArrayFilter($item, $condition, $compare)));
 
-            case Operator::TYPE_DATE_ADD_DAYS:
-                $days = (int) ($values[0] ?? 0);
+            case OperatorType::DateAddDays:
+                $days = (int) $this->numericValue($values[0] ?? null, 0);
 
                 return $this->shiftDate($current, $days * 86400);
 
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $days = (int) ($values[0] ?? 0);
+            case OperatorType::DateSubDays:
+                $days = (int) $this->numericValue($values[0] ?? null, 0);
 
                 return $this->shiftDate($current, -$days * 86400);
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return DateTime::now();
         }
+    }
+
+    /**
+     * Coerce a mixed value to int|float, falling back to $default when the
+     * value is not numeric. Centralises the narrow-to-numeric pattern used
+     * across the operator implementations.
+     */
+    protected function numericValue(mixed $value, int|float|null $default): int|float|null
+    {
+        if (\is_int($value) || \is_float($value)) {
+            return $value;
+        }
+        if (\is_string($value) && \is_numeric($value)) {
+            return $value + 0;
+        }
 
-        throw new OperatorException("Invalid operator: {$method}");
+        return $default;
     }
 
     /**
-     * Clamp an arithmetic result against an optional bound.
+     * Coerce a mixed value to string, falling back to '' when the value is
+     * not stringable. Centralises the narrow-to-string pattern used across
+     * the string-operator implementations.
+     */
+    protected function stringValue(mixed $value): string
+    {
+        if (\is_string($value)) {
+            return $value;
+        }
+        if (\is_scalar($value) || $value === null) {
+            return (string) $value;
+        }
+
+        return '';
+    }
+
+    /**
+     * Apply an arithmetic result unless it crosses an optional bound.
      *
      * @param  bool  $isUpper  true = bound is a maximum, false = minimum
      */
-    protected function applyNumericLimit(int|float $value, int|float|null $bound, bool $isUpper): int|float
+    protected function applyNumericLimit(mixed $original, mixed $candidate, mixed $bound, bool $isUpper): int|float|string
     {
-        if ($bound === null) {
-            return $value;
+        if (BigInt::isIntegerValue($original) && BigInt::isIntegerValue($candidate) && BigInt::isIntegerValue($bound)) {
+            $crossed = $isUpper
+                ? BigInt::compare($candidate, $bound) > 0
+                : BigInt::compare($candidate, $bound) < 0;
+
+            return $crossed ? BigInt::toNative($original) : $candidate;
+        }
+
+        $numericOriginal = \is_numeric($original) ? $original + 0 : 0;
+        $numericCandidate = \is_numeric($candidate) ? $candidate + 0 : 0;
+        $numericBound = \is_numeric($bound) ? $bound + 0 : null;
+
+        if ($numericBound !== null && (($isUpper && $numericCandidate > $numericBound) || (! $isUpper && $numericCandidate < $numericBound))) {
+            return $numericOriginal;
         }
 
-        return $isUpper ? \min($value, $bound) : \max($value, $bound);
+        return $this->preserveNumericType($numericOriginal, $numericCandidate);
     }
 
     /**
@@ -3696,20 +3576,20 @@ protected function coerceArray(mixed $value): array
     }
 
     /**
-     * Mirror Operator::TYPE_ARRAY_FILTER's case-by-case predicate translation
+     * Mirror OperatorType::ArrayFilter's case-by-case predicate translation
      * (see MariaDB JSON_TABLE filter — `equal`, `greaterThan`, `isNull`, ...).
      */
     protected function matchesArrayFilter(mixed $item, string $condition, mixed $compare): bool
     {
         return match ($condition) {
-            Query::TYPE_EQUAL => $item == $compare,
-            Query::TYPE_NOT_EQUAL => $item != $compare,
-            Query::TYPE_GREATER => \is_numeric($item) && \is_numeric($compare) && $item + 0 > $compare + 0,
-            Query::TYPE_GREATER_EQUAL => \is_numeric($item) && \is_numeric($compare) && $item + 0 >= $compare + 0,
-            Query::TYPE_LESSER => \is_numeric($item) && \is_numeric($compare) && $item + 0 < $compare + 0,
-            Query::TYPE_LESSER_EQUAL => \is_numeric($item) && \is_numeric($compare) && $item + 0 <= $compare + 0,
-            Query::TYPE_IS_NULL => $item === null,
-            Query::TYPE_IS_NOT_NULL => $item !== null,
+            Method::Equal->value => $item == $compare,
+            Method::NotEqual->value => $item != $compare,
+            Method::GreaterThan->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 > $compare + 0,
+            Method::GreaterThanEqual->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 >= $compare + 0,
+            Method::LessThan->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 < $compare + 0,
+            Method::LessThanEqual->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 <= $compare + 0,
+            Method::IsNull->value => $item === null,
+            Method::IsNotNull->value => $item !== null,
             default => true,
         };
     }
@@ -3724,10 +3604,11 @@ protected function shiftDate(mixed $current, int $seconds): ?string
         if ($current === null) {
             return null;
         }
+        $stringValue = $this->stringValue($current);
         try {
-            $base = new \DateTime((string) $current);
+            $base = new \DateTime($stringValue);
         } catch (\Throwable) {
-            return $current === '' ? null : (string) $current;
+            return $stringValue === '' ? null : $stringValue;
         }
         $base->modify(($seconds >= 0 ? '+' : '').$seconds.' seconds');
 
diff --git a/src/Database/Adapter/Mongo.php b/src/Database/Adapter/Mongo.php
index 136ebac0f2..7627e6bc08 100644
--- a/src/Database/Adapter/Mongo.php
+++ b/src/Database/Adapter/Mongo.php
@@ -2,15 +2,22 @@
 
 namespace Utopia\Database\Adapter;
 
+use DateTime as NativeDateTime;
+use DateTimeZone;
 use Exception;
+use MongoDB\BSON\Int64;
 use MongoDB\BSON\Regex;
 use MongoDB\BSON\UTCDateTime;
 use stdClass;
+use Throwable;
 use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Change;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
 use Utopia\Database\Exception\Conflict as ConflictException;
@@ -18,18 +25,35 @@
 use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\Relationship as RelationshipException;
 use Utopia\Database\Exception\Restricted as RestrictedException;
-use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Exception\Type as TypeException;
 use Utopia\Database\Exception\Unique as UniqueException;
+use Utopia\Database\Hook\Mongo\PermissionFilter as MongoPermissionFilter;
+use Utopia\Database\Hook\Mongo\TenantFilter as MongoTenantFilter;
+use Utopia\Database\Hook\Read;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\BigInt;
 use Utopia\Mongo\Client;
 use Utopia\Mongo\Exception as MongoException;
-
-class Mongo extends Adapter
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Method;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Database adapter for MongoDB, using the Utopia Mongo client for document-based storage.
+ */
+class Mongo extends Adapter implements Feature\InternalCasting, Feature\Relationships, Feature\Timeouts, Feature\Upserts, Feature\UTCCasting
 {
     /**
      * @var array<string>
@@ -53,11 +77,16 @@ class Mongo extends Adapter
         '$nor',
         '$exists',
         '$elemMatch',
-        '$exists'
+        '$exists',
     ];
 
     protected Client $client;
 
+    /**
+     * @var list<Read>
+     */
+    protected array $readHooks = [];
+
     /**
      * Default batch size for cursor operations
      */
@@ -65,10 +94,13 @@ class Mongo extends Adapter
 
     /**
      * Transaction/session state for MongoDB transactions
-     * @var array<string, mixed>|null $session
+     *
+     * @var array<mixed>|null
      */
     private ?array $session = null; // Store session array from startSession
+
     protected int $inTransaction = 0;
+
     protected bool $supportForAttributes = true;
 
     /**
@@ -76,7 +108,6 @@ class Mongo extends Adapter
      *
      * Set connection and settings
      *
-     * @param Client $client
      * @throws MongoException
      */
     public function __construct(Client $client)
@@ -99,126 +130,192 @@ public function getDriver(): mixed
         return $this->client;
     }
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
-    {
-        if (!$this->getSupportForTimeouts()) {
-            return;
-        }
+    /**
+     * Get the list of capabilities supported by the MongoDB adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::Objects,
+            Capability::Fulltext,
+            Capability::TTLIndexes,
+            Capability::Regex,
+            Capability::BatchCreateAttributes,
+            Capability::Caching,
+            Capability::Hostname,
+            Capability::PCRE,
+            Capability::Operators,
+            Capability::TransactionRetries,
+            Capability::Upserts,
+        ]);
+    }
 
+    /**
+     * Set the maximum execution time for queries.
+     *
+     * @param int $milliseconds Timeout in milliseconds
+     * @param Event $event The event scope for the timeout
+     * @return void
+     */
+    #[\Override]
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
+    {
         $this->timeout = $milliseconds;
     }
 
-    public function clearTimeout(string $event): void
+    /**
+     * Clear the query execution timeout.
+     *
+     * @param Event $event The event scope to clear
+     * @return void
+     */
+    #[\Override]
+    public function clearTimeout(Event $event = Event::All): void
     {
-        parent::clearTimeout($event);
-
         $this->timeout = 0;
     }
 
     /**
-     * @template T
-     * @param callable(): T $callback
-     * @return T
-     * @throws \Throwable
+     * Set whether the adapter supports schema-based attribute definitions.
+     *
+     * @param bool $support Whether to enable attribute support
+     * @return bool
      */
-    public function withTransaction(callable $callback): mixed
+    public function setSupportForAttributes(bool $support): bool
     {
-        // If the database is not a replica set, we can't use transactions
-        if (!$this->client->isReplicaSet()) {
-            return $callback();
-        }
+        $this->supportForAttributes = $support;
+        $this->capabilitySet = null;
 
-        // MongoDB doesn't support nested transactions/savepoints.
-        // If already in a transaction, just run the callback directly.
-        if ($this->inTransaction > 0) {
-            return $callback();
+        return $this->supportForAttributes;
+    }
+
+    public function supports(Capability $feature): bool
+    {
+        if ($feature === Capability::DefinedAttributes) {
+            return $this->supportForAttributes;
         }
 
-        // upsert + $setOnInsert hits WriteConflict (E112) under txn snapshot isolation.
-        if ($this->skipDuplicates) {
-            return $callback();
+        return parent::supports($feature);
+    }
+
+    protected function syncWriteHooks(): void
+    {
+    }
+
+    protected function syncReadHooks(): void
+    {
+        $this->readHooks = [];
+
+        if ($this->sharedTables && $this->tenant !== null) {
+            $this->readHooks[] = new MongoTenantFilter(
+                $this->tenant,
+                $this->sharedTables,
+                fn (string $collection, array $tenants = []) => $this->getTenantFilters($collection, $tenants),
+            );
         }
 
-        $sleep = 50_000; // 50 milliseconds
-        $retries = 2;
+        if ($this->hasPermissionHook()) {
+            $this->readHooks[] = new MongoPermissionFilter($this->authorization);
+        }
+    }
 
-        for ($attempts = 0; $attempts <= $retries; $attempts++) {
-            try {
-                $this->startTransaction();
-                $result = $callback();
-                $this->commitTransaction();
-                return $result;
-            } catch (\Throwable $action) {
-                try {
-                    $this->rollbackTransaction();
-                } catch (\Throwable) {
-                    // Throw the original exception, not the rollback one
-                    // Since if it's a duplicate key error, the rollback will fail,
-                    // and we want to throw the original exception.
-                } finally {
-                    // Ensure state is cleaned up even if rollback fails
-                    if ($this->session) {
-                        try {
-                            $this->client->endSessions([$this->session]);
-                        } catch (\Throwable $endSessionError) {
-                            // Ignore errors when ending session during error cleanup
-                        }
-                    }
-                    $this->inTransaction = 0;
-                    $this->session = null;
-                }
+    /**
+     * @param  array<string, mixed>  $filters
+     * @return array<string, mixed>
+     */
+    protected function applyReadFilters(array $filters, string $collection, string $forPermission = 'read'): array
+    {
+        $this->syncReadHooks();
+        foreach ($this->readHooks as $hook) {
+            $filters = $hook->applyFilters($filters, $collection, $forPermission);
+        }
 
-                if (
-                    $action instanceof DuplicateException ||
-                    $action instanceof RestrictedException ||
-                    $action instanceof AuthorizationException ||
-                    $action instanceof RelationshipException ||
-                    $action instanceof ConflictException ||
-                    $action instanceof LimitException ||
-                    $action instanceof TimeoutException
-                ) {
-                    throw $action;
-                }
+        return $filters;
+    }
 
-                if ($attempts < $retries) {
-                    \usleep($sleep * ($attempts + 1));
-                    continue;
-                }
+    /**
+     * Ping Database
+     *
+     * @throws Exception
+     * @throws MongoException
+     */
+    public function ping(): bool
+    {
+        /** @var \stdClass|array<string, mixed>|int $result */
+        $result = $this->getClient()->query([
+            'ping' => 1,
+            'skipReadConcern' => true,
+        ]);
 
-                throw $action;
-            }
+        if ($result instanceof \stdClass && isset($result->ok)) {
+            return (bool) $result->ok;
         }
 
-        throw new TransactionException('Failed to execute transaction');
+        return false;
+    }
+
+    /**
+     * Reconnect to the MongoDB server.
+     *
+     * @return void
+     */
+    public function reconnect(): void
+    {
+        $this->client->connect();
+    }
+
+    /**
+     * @throws Exception
+     */
+    protected function getClient(): Client
+    {
+        return $this->client;
     }
 
+    /**
+     * Start a new database transaction or increment the nesting counter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException If the transaction cannot be started.
+     */
     public function startTransaction(): bool
     {
         // If the database is not a replica set, we can't use transactions
-        if (!$this->client->isReplicaSet()) {
+        if (! $this->client->isReplicaSet()) {
             return true;
         }
 
         try {
             if ($this->inTransaction === 0) {
-                if (!$this->session) {
+                if (! $this->session) {
                     $this->session = $this->client->startSession(); // Get session array
                     $this->client->startTransaction($this->session); // Start the transaction
                 }
             }
             $this->inTransaction++;
+
             return true;
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             $this->session = null;
             $this->inTransaction = 0;
-            throw new DatabaseException('Failed to start transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new DatabaseException('Failed to start transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
     }
 
+    /**
+     * Commit the current database transaction or decrement the nesting counter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException If the transaction cannot be committed.
+     */
     public function commitTransaction(): bool
     {
         // If the database is not a replica set, we can't use transactions
-        if (!$this->client->isReplicaSet()) {
+        if (! $this->client->isReplicaSet()) {
             return true;
         }
 
@@ -228,7 +325,7 @@ public function commitTransaction(): bool
             }
             $this->inTransaction--;
             if ($this->inTransaction === 0) {
-                if (!$this->session) {
+                if (! $this->session) {
                     return false;
                 }
                 try {
@@ -241,10 +338,11 @@ public function commitTransaction(): bool
                         $this->client->endSessions([$this->session]);
                         $this->session = null;
                         $this->inTransaction = 0;  // Reset counter when transaction is already terminated
+
                         return true;
                     }
                     throw $e;
-                } catch (\Throwable $e) {
+                } catch (Throwable $e) {
                     throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
                 } finally {
                     if ($this->session) {
@@ -255,24 +353,34 @@ public function commitTransaction(): bool
 
                 return true;
             }
+
             return true;
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             // Ensure cleanup on any failure
             try {
-                $this->client->endSessions([$this->session]);
-            } catch (\Throwable $endSessionError) {
+                if ($this->session !== null) {
+                    $this->client->endSessions([$this->session]);
+                }
+            } catch (Throwable $endSessionError) {
                 // Ignore errors when ending session during error cleanup
             }
             $this->session = null;
             $this->inTransaction = 0;
-            throw new DatabaseException('Failed to commit transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new DatabaseException('Failed to commit transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
     }
 
+    /**
+     * Roll back the current database transaction or decrement the nesting counter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException If the rollback fails.
+     */
     public function rollbackTransaction(): bool
     {
         // If the database is not a replica set, we can't use transactions
-        if (!$this->client->isReplicaSet()) {
+        if (! $this->client->isReplicaSet()) {
             return true;
         }
 
@@ -282,13 +390,13 @@ public function rollbackTransaction(): bool
             }
             $this->inTransaction--;
             if ($this->inTransaction === 0) {
-                if (!$this->session) {
+                if (! $this->session) {
                     return false;
                 }
 
                 try {
                     $this->client->abortTransaction($this->session);
-                } catch (\Throwable $e) {
+                } catch (Throwable $e) {
                     $e = $this->processException($e);
 
                     if ($e instanceof TransactionException) {
@@ -305,85 +413,103 @@ public function rollbackTransaction(): bool
 
                 return true;
             }
+
             return true;
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             try {
-                $this->client->endSessions([$this->session]);
-            } catch (\Throwable) {
+                if ($this->session !== null) {
+                    $this->client->endSessions([$this->session]);
+                }
+            } catch (Throwable) {
                 // Ignore errors when ending session during error cleanup
             }
             $this->session = null;
             $this->inTransaction = 0;
 
-            throw new DatabaseException('Failed to rollback transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new DatabaseException('Failed to rollback transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
     }
 
     /**
-     * Helper to add transaction/session context to command options if in transaction
-     * Includes defensive check to ensure session is valid
+     * @template T
      *
-     * @param array<string, mixed> $options
-     * @return array<string, mixed>
+     * @param  callable(): T  $callback
+     * @return T
+     *
+     * @throws Throwable
      */
-    private function getTransactionOptions(array $options = []): array
+    public function withTransaction(callable $callback): mixed
     {
-        if ($this->inTransaction > 0 && $this->session !== null) {
-            // Pass the session array directly - the client will handle the transaction state internally
-            $options['session'] = $this->session;
+        // If the database is not a replica set, we can't use transactions
+        if (! $this->client->isReplicaSet()) {
+            return $callback();
         }
-        return $options;
-    }
 
+        // MongoDB doesn't support nested transactions/savepoints.
+        // If already in a transaction, just run the callback directly.
+        if ($this->inTransaction > 0) {
+            return $callback();
+        }
 
-    /**
-     * Create a safe MongoDB regex pattern by escaping special characters
-     *
-     * @param string $value The user input to escape
-     * @param string $pattern The pattern template (e.g., ".*%s.*" for contains)
-     * @return Regex
-     * @throws DatabaseException
-     */
-    private function createSafeRegex(string $value, string $pattern = '%s', string $flags = 'i'): Regex
-    {
-        $escaped = preg_quote($value, '/');
-
-        // Validate that the pattern doesn't contain injection vectors
-        if (preg_match('/\$[a-z]+/i', $escaped)) {
-            throw new DatabaseException('Invalid regex pattern: potential injection detected');
+        // upsert + $setOnInsert hits WriteConflict (E112) under txn snapshot isolation.
+        if ($this->skipDuplicates) {
+            return $callback();
         }
 
-        $finalPattern = sprintf($pattern, $escaped);
+        $sleep = 50_000;
+        $retries = 2;
 
-        return new Regex($finalPattern, $flags);
-    }
+        for ($attempts = 0; $attempts <= $retries; $attempts++) {
+            try {
+                $this->startTransaction();
+                $result = $callback();
+                $this->commitTransaction();
 
-    /**
-     * Ping Database
-     *
-     * @return bool
-     * @throws Exception
-     * @throws MongoException
-     */
-    public function ping(): bool
-    {
-        return $this->getClient()->query([
-            'ping' => 1,
-            'skipReadConcern' => true
-        ])->ok ?? false;
-    }
+                return $result;
+            } catch (Throwable $action) {
+                try {
+                    $this->rollbackTransaction();
+                } catch (Throwable) {
+                    // Preserve the operation failure if cleanup fails.
+                } finally {
+                    if ($this->session !== null) {
+                        try {
+                            $this->client->endSessions([$this->session]);
+                        } catch (Throwable) {
+                            // Cleanup is best-effort; preserve the operation failure.
+                        }
+                    }
+                    $this->inTransaction = 0;
+                    $this->session = null;
+                }
 
-    public function reconnect(): void
-    {
-        $this->client->connect();
+                if (
+                    $action instanceof AuthorizationException
+                    || $action instanceof ConflictException
+                    || $action instanceof DuplicateException
+                    || $action instanceof LimitException
+                    || $action instanceof RelationshipException
+                    || $action instanceof RestrictedException
+                    || $action instanceof TimeoutException
+                ) {
+                    throw $action;
+                }
+
+                if ($attempts < $retries) {
+                    \usleep($sleep * ($attempts + 1));
+
+                    continue;
+                }
+
+                throw $action;
+            }
+        }
+
+        throw new TransactionException('Transaction retry loop exited unexpectedly');
     }
 
     /**
      * Create Database
-     *
-     * @param string $name
-     *
-     * @return bool
      */
     public function create(string $name): bool
     {
@@ -394,25 +520,29 @@ public function create(string $name): bool
      * Check if database exists
      * Optionally check if collection exists in database
      *
-     * @param string $database database name
-     * @param string|null $collection (optional) collection name
+     * @param  string  $database  database name
+     * @param  string|null  $collection  (optional) collection name
      *
-     * @return bool
      * @throws Exception
      */
     public function exists(string $database, ?string $collection = null): bool
     {
-        if (!\is_null($collection)) {
-            $collection = $this->getNamespace() . "_" . $collection;
+        if (! \is_null($collection)) {
+            $collection = $this->getNamespace().'_'.$collection;
             try {
                 // Use listCollections command with filter for O(1) lookup
+                /** @var \stdClass $result */
                 $result = $this->getClient()->query([
                     'listCollections' => 1,
-                    'filter' => ['name' => $collection]
+                    'filter' => ['name' => $collection],
                 ]);
 
-                return !empty($result->cursor->firstBatch);
-            } catch (\Exception $e) {
+                /** @var \stdClass $cursor */
+                $cursor = $result->cursor;
+                /** @var array<mixed> $firstBatch */
+                $firstBatch = $cursor->firstBatch;
+                return ! empty($firstBatch);
+            } catch (Exception $e) {
                 return false;
             }
         }
@@ -424,13 +554,19 @@ public function exists(string $database, ?string $collection = null): bool
      * List Databases
      *
      * @return array<Document>
+     *
      * @throws Exception
      */
     public function list(): array
     {
+        /** @var array<Document> $list */
         $list = [];
 
-        foreach ((array)$this->getClient()->listDatabaseNames() as $value) {
+        /** @var \stdClass $databaseNames */
+        $databaseNames = $this->getClient()->listDatabaseNames();
+        /** @var array<Document> $databaseNamesArray */
+        $databaseNamesArray = (array) $databaseNames;
+        foreach ($databaseNamesArray as $value) {
             $list[] = $value;
         }
 
@@ -440,9 +576,7 @@ public function list(): array
     /**
      * Delete Database
      *
-     * @param string $name
      *
-     * @return bool
      * @throws Exception
      */
     public function delete(string $name): bool
@@ -455,20 +589,19 @@ public function delete(string $name): bool
     /**
      * Create Collection
      *
-     * @param string $name
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     * @param  array<Index>  $indexes
+     *
      * @throws Exception
      */
     public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
     {
-        $id = $this->getNamespace() . '_' . $this->filter($name);
+        $id = $this->getNamespace().'_'.$this->filter($name);
 
         // In shared-tables mode or for metadata, the physical collection may
         // already exist for another tenant. Return early to avoid a
         // "Collection Exists" exception from the client.
-        if (!$this->inTransaction && ($this->getSharedTables() || $name === Database::METADATA) && $this->exists($this->getNamespace(), $name)) {
+        if (! $this->inTransaction && ($this->getSharedTables() || $name === Database::METADATA) && $this->exists($this->getNamespace(), $name)) {
             return true;
         }
 
@@ -477,6 +610,10 @@ public function createCollection(string $name, array $attributes = [], array $in
             $options = $this->getTransactionOptions();
             $this->getClient()->createCollection($id, $options);
         } catch (MongoException $e) {
+            // Client throws "Collection Exists" (code 0) if it already exists
+            if (\str_contains($e->getMessage(), 'Collection Exists')) {
+                return true;
+            }
             $e = $this->processException($e);
             if ($e instanceof DuplicateException) {
                 if ($this->getSharedTables() || $name === Database::METADATA) {
@@ -499,8 +636,8 @@ public function createCollection(string $name, array $attributes = [], array $in
 
         $internalIndex = [
             [
-                'key' => ['_uid' => $this->getOrder(Database::ORDER_ASC)],
-                'name' => '_uid',
+                'key' => [Storage::UID => $this->getOrder(OrderDirection::Asc)],
+                'name' => Storage::UID,
                 'unique' => true,
                 'collation' => [
                     'locale' => 'en',
@@ -508,22 +645,22 @@ public function createCollection(string $name, array $attributes = [], array $in
                 ],
             ],
             [
-                'key' => ['_createdAt' => $this->getOrder(Database::ORDER_ASC)],
-                'name' => '_createdAt',
+                'key' => [Storage::CREATED_AT => $this->getOrder(OrderDirection::Asc)],
+                'name' => Storage::CREATED_AT,
             ],
             [
-                'key' => ['_updatedAt' => $this->getOrder(Database::ORDER_ASC)],
-                'name' => '_updatedAt',
+                'key' => [Storage::UPDATED_AT => $this->getOrder(OrderDirection::Asc)],
+                'name' => Storage::UPDATED_AT,
             ],
             [
-                'key' => ['_permissions' => $this->getOrder(Database::ORDER_ASC)],
-                'name' => '_permissions',
-            ]
+                'key' => [Storage::PERMISSIONS => $this->getOrder(OrderDirection::Asc)],
+                'name' => Storage::PERMISSIONS,
+            ],
         ];
 
         if ($this->sharedTables) {
             foreach ($internalIndex as &$index) {
-                $index['key'] = array_merge(['_tenant' => $this->getOrder(Database::ORDER_ASC)], $index['key']);
+                $index['key'] = array_merge([Storage::TENANT => $this->getOrder(OrderDirection::Asc)], $index['key']);
             }
             unset($index);
         }
@@ -531,18 +668,18 @@ public function createCollection(string $name, array $attributes = [], array $in
         try {
             $options = $this->getTransactionOptions();
             $indexesCreated = $this->client->createIndexes($id, $internalIndex, $options);
-        } catch (\Exception $e) {
+        } catch (Exception $e) {
             throw $this->processException($e);
         }
 
-        if (!$indexesCreated) {
+        if (! $indexesCreated) {
             return false;
         }
 
         // Since attributes are not used by this adapter
         // Only act when $indexes is provided
 
-        if (!empty($indexes)) {
+        if (! empty($indexes)) {
             /**
              * Each new index has format ['key' => [$attribute => $order], 'name' => $name, 'unique' => $unique]
              */
@@ -555,32 +692,31 @@ public function createCollection(string $name, array $attributes = [], array $in
 
                 $key = [];
                 $unique = false;
-                $attributes = $index->getAttribute('attributes');
-                $orders = $index->getAttribute('orders');
+                $attributes = $index->attributes;
+                $orders = $index->orders;
 
                 // If sharedTables, always add _tenant as the first key
                 if ($this->shouldAddTenantToIndex($index)) {
-                    $key['_tenant'] = $this->getOrder(Database::ORDER_ASC);
+                    $key[Storage::TENANT] = $this->getOrder(OrderDirection::Asc);
                 }
 
                 foreach ($attributes as $j => $attribute) {
-                    $attribute = $this->filter($this->getInternalKeyForAttribute($attribute));
+                    $attribute = $this->filter($this->getInternalKeyForAttribute((string) $attribute));
 
-                    switch ($index->getAttribute('type')) {
-                        case Database::INDEX_KEY:
-                            $order = $this->getOrder($this->filter($orders[$j] ?? Database::ORDER_ASC));
+                    switch ($index->type) {
+                        case IndexType::Key:
+                            $order = $this->getOrder(OrderDirection::tryFrom(Index::direction($orders[$j] ?? null)) ?? OrderDirection::Asc);
                             break;
-                        case Database::INDEX_FULLTEXT:
+                        case IndexType::Fulltext:
                             // MongoDB fulltext index is just 'text'
-                            // Not using Database::INDEX_KEY for clarity
                             $order = 'text';
                             break;
-                        case Database::INDEX_UNIQUE:
-                            $order = $this->getOrder($this->filter($orders[$j] ?? Database::ORDER_ASC));
+                        case IndexType::Unique:
+                            $order = $this->getOrder(OrderDirection::tryFrom(Index::direction($orders[$j] ?? null)) ?? OrderDirection::Asc);
                             $unique = true;
                             break;
-                        case Database::INDEX_TTL:
-                            $order = $this->getOrder($this->filter($orders[$j] ?? Database::ORDER_ASC));
+                        case IndexType::Ttl:
+                            $order = $this->getOrder(OrderDirection::tryFrom(Index::direction($orders[$j] ?? null)) ?? OrderDirection::Asc);
                             break;
                         default:
                             // index not supported
@@ -592,34 +728,35 @@ public function createCollection(string $name, array $attributes = [], array $in
 
                 $newIndexes[$i] = [
                     'key' => $key,
-                    'name' => $this->filter($index->getId()),
-                    'unique' => $unique
+                    'name' => $this->filter($index->key),
+                    'unique' => $unique,
                 ];
 
-                if ($index->getAttribute('type') === Database::INDEX_FULLTEXT) {
+                if ($index->type === IndexType::Fulltext) {
                     $newIndexes[$i]['default_language'] = 'none';
                 }
 
                 // Handle TTL indexes
-                if ($index->getAttribute('type') === Database::INDEX_TTL) {
-                    $ttl = $index->getAttribute('ttl', 0);
+                if ($index->type === IndexType::Ttl) {
+                    $ttl = $index->ttl;
                     if ($ttl > 0) {
                         $newIndexes[$i]['expireAfterSeconds'] = $ttl;
                     }
                 }
 
                 // Add partial filter for indexes to avoid indexing null values
-                if (in_array($index->getAttribute('type'), [
-                    Database::INDEX_UNIQUE,
-                    Database::INDEX_KEY
+                if (in_array($index->type, [
+                    IndexType::Unique,
+                    IndexType::Key,
                 ])) {
                     $partialFilter = [];
                     foreach ($attributes as $attr) {
+                        $attr = (string) $attr;
                         // Find the matching attribute in collectionAttributes to get its type
                         $attrType = 'string'; // Default fallback
                         foreach ($collectionAttributes as $collectionAttr) {
-                            if ($collectionAttr->getId() === $attr) {
-                                $attrType = $this->getMongoTypeCode($collectionAttr->getAttribute('type'));
+                            if ($collectionAttr->key === $attr) {
+                                $attrType = $this->getMongoTypeCode($collectionAttr->type);
                                 break;
                             }
                         }
@@ -629,10 +766,10 @@ public function createCollection(string $name, array $attributes = [], array $in
                         // Use both $exists: true and $type to exclude nulls and ensure correct type
                         $partialFilter[$attr] = [
                             '$exists' => true,
-                            '$type' => $attrType
+                            '$type' => $attrType,
                         ];
                     }
-                    if (!empty($partialFilter)) {
+                    if (! empty($partialFilter)) {
                         $newIndexes[$i]['partialFilterExpression'] = $partialFilter;
                     }
                 }
@@ -640,12 +777,12 @@ public function createCollection(string $name, array $attributes = [], array $in
 
             try {
                 $options = $this->getTransactionOptions();
-                $indexesCreated = $this->getClient()->createIndexes($id, $newIndexes, $options);
-            } catch (\Exception $e) {
+                $indexesCreated = $this->getClient()->createIndexes($id, \array_values($newIndexes), $options);
+            } catch (Exception $e) {
                 throw $this->processException($e);
             }
 
-            if (!$indexesCreated) {
+            if (! $indexesCreated) {
                 return false;
             }
         }
@@ -657,15 +794,21 @@ public function createCollection(string $name, array $attributes = [], array $in
      * List Collections
      *
      * @return array<Document>
+     *
      * @throws Exception
      */
     public function listCollections(): array
     {
+        /** @var array<Document> $list */
         $list = [];
 
         // Note: listCollections is a metadata operation that should not run in transactions
         // to avoid transaction conflicts and readConcern issues
-        foreach ((array)$this->getClient()->listCollectionNames() as $value) {
+        /** @var \stdClass $collectionNames */
+        $collectionNames = $this->getClient()->listCollectionNames();
+        /** @var array<Document> $collectionNamesArray */
+        $collectionNamesArray = (array) $collectionNames;
+        foreach ($collectionNamesArray as $value) {
             $list[] = $value;
         }
 
@@ -673,111 +816,67 @@ public function listCollections(): array
     }
 
     /**
-     * Get Collection Size on disk
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
+     * Delete Collection
+     *
+     * @throws Exception
      */
-    public function getSizeOfCollectionOnDisk(string $collection): int
+    public function deleteCollection(string $id): bool
     {
-        return $this->getSizeOfCollection($collection);
+        $id = $this->getNamespace().'_'.$this->filter($id);
+
+        return (bool) $this->getClient()->dropCollection($id);
     }
 
     /**
-     * Get Collection Size of raw data
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
+     * Analyze a collection updating it's metadata on the database engine
      */
-    public function getSizeOfCollection(string $collection): int
+    public function analyzeCollection(string $collection): bool
     {
-        $namespace = $this->getNamespace();
-        $collection = $this->filter($collection);
-        $collection = $namespace . '_' . $collection;
-
-        $command = [
-            'collStats' => $collection,
-            'scale' => 1
-        ];
-
-        try {
-            $result = $this->getClient()->query($command);
-            if (is_object($result)) {
-                return $result->totalSize;
-            } else {
-                throw new DatabaseException('No size found');
-            }
-        } catch (Exception $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
-        }
+        return false;
     }
 
     /**
-     * Delete Collection
-     *
-     * @param string $id
-     * @return bool
-     * @throws Exception
+     * Create Attribute
      */
-    public function deleteCollection(string $id): bool
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        $id = $this->getNamespace() . '_' . $this->filter($id);
-        return (!!$this->getClient()->dropCollection($id));
+        return true;
     }
 
     /**
-     * Analyze a collection updating it's metadata on the database engine
+     * Create Attributes
      *
-     * @param string $collection
-     * @return bool
-     */
-    public function analyzeCollection(string $collection): bool
-    {
-        return false;
-    }
-
-    /**
-     * Create Attribute
+     * @param  array<Attribute>  $attributes
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @return bool
+     * @throws DatabaseException
      */
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
+    public function createAttributes(string $collection, array $attributes): bool
     {
         return true;
     }
 
     /**
-     * Create Attributes
-     *
-     * @param string $collection
-     * @param array<array<string, mixed>> $attributes
-     * @return bool
-     * @throws DatabaseException
+     * Update Attribute.
      */
-    public function createAttributes(string $collection, array $attributes): bool
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
     {
+        if (! empty($newKey) && $newKey !== $attribute->key) {
+            return $this->renameAttribute($collection, $attribute->key, $newKey);
+        }
+
         return true;
     }
 
     /**
      * Delete Attribute
      *
-     * @param string $collection
-     * @param string $id
      *
-     * @return bool
      * @throws DatabaseException
      * @throws MongoException
      */
     public function deleteAttribute(string $collection, string $id): bool
     {
-        $collection = $this->getNamespace() . '_' . $this->filter($collection);
+        $collection = $this->getNamespace().'_'.$this->filter($collection);
 
         $this->getClient()->update(
             $collection,
@@ -792,19 +891,15 @@ public function deleteAttribute(string $collection, string $id): bool
     /**
      * Rename Attribute.
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $name
-     * @return bool
      * @throws DatabaseException
      * @throws MongoException
      */
     public function renameAttribute(string $collection, string $id, string $name): bool
     {
-        $collection = $this->getNamespace() . '_' . $this->filter($collection);
+        $collection = $this->getNamespace().'_'.$this->filter($collection);
 
-        $from    = $this->filter($this->getInternalKeyForAttribute($id));
-        $to      = $this->filter($this->getInternalKeyForAttribute($name));
+        $from = $this->filter($this->getInternalKeyForAttribute($id));
+        $to = $this->filter($this->getInternalKeyForAttribute($name));
         $options = $this->getTransactionOptions();
 
         $this->getClient()->update(
@@ -819,100 +914,81 @@ public function renameAttribute(string $collection, string $id, string $name): b
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $id
-     * @param string $twoWayKey
+     * Create a relationship between collections. No-op for MongoDB since relationships are virtual.
+     *
+     * @param Relationship $relationship The relationship definition
      * @return bool
      */
-    public function createRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay = false, string $id = '', string $twoWayKey = ''): bool
+    public function createRelationship(Relationship $relationship): bool
     {
         return true;
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @param string|null $newKey
-     * @param string|null $newTwoWayKey
-     * @return bool
      * @throws DatabaseException
      * @throws MongoException
      */
     public function updateRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side,
+        Relationship $relationship,
         ?string $newKey = null,
         ?string $newTwoWayKey = null
     ): bool {
-        $collectionName = $this->getNamespace() . '_' . $this->filter($collection);
-        $relatedCollectionName = $this->getNamespace() . '_' . $this->filter($relatedCollection);
+        $collectionName = $this->getNamespace().'_'.$this->filter($relationship->collection);
+        $relatedCollectionName = $this->getNamespace().'_'.$this->filter($relationship->relatedCollection);
 
-        $escapedKey = $this->escapeMongoFieldName($key);
-        $escapedNewKey = !\is_null($newKey) ? $this->escapeMongoFieldName($newKey) : null;
-        $escapedTwoWayKey = $this->escapeMongoFieldName($twoWayKey);
-        $escapedNewTwoWayKey = !\is_null($newTwoWayKey) ? $this->escapeMongoFieldName($newTwoWayKey) : null;
+        $escapedKey = $this->escapeMongoFieldName($relationship->key);
+        $escapedNewKey = ! \is_null($newKey) ? $this->escapeMongoFieldName($newKey) : null;
+        $escapedTwoWayKey = $this->escapeMongoFieldName($relationship->twoWayKey);
+        $escapedNewTwoWayKey = ! \is_null($newTwoWayKey) ? $this->escapeMongoFieldName($newTwoWayKey) : null;
 
         $renameKey = [
             '$rename' => [
                 $escapedKey => $escapedNewKey,
-            ]
+            ],
         ];
 
         $renameTwoWayKey = [
             '$rename' => [
                 $escapedTwoWayKey => $escapedNewTwoWayKey,
-            ]
+            ],
         ];
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if (!\is_null($newKey) && $key !== $newKey) {
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if (! \is_null($newKey) && $relationship->key !== $newKey) {
                     $this->getClient()->update($collectionName, updates: $renameKey, multi: true);
                 }
-                if ($twoWay && !\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+                if ($relationship->twoWay && ! \is_null($newTwoWayKey) && $relationship->twoWayKey !== $newTwoWayKey) {
                     $this->getClient()->update($relatedCollectionName, updates: $renameTwoWayKey, multi: true);
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($twoWay && !\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+            case RelationType::OneToMany:
+                if ($relationship->twoWay && ! \is_null($newTwoWayKey) && $relationship->twoWayKey !== $newTwoWayKey) {
                     $this->getClient()->update($relatedCollectionName, updates: $renameTwoWayKey, multi: true);
                 }
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                if (!\is_null($newKey) && $key !== $newKey) {
+            case RelationType::ManyToOne:
+                if (! \is_null($newKey) && $relationship->key !== $newKey) {
                     $this->getClient()->update($collectionName, updates: $renameKey, multi: true);
                 }
                 break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collectionDoc = $this->getDocument($metadataCollection, $collection);
-                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collectionDoc = $this->getDocument($metadataCollection, $relationship->collection);
+                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relationship->relatedCollection);
 
                 if ($collectionDoc->isEmpty() || $relatedCollectionDoc->isEmpty()) {
                     throw new DatabaseException('Collection or related collection not found');
                 }
 
-                $junction = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getNamespace() . '_' . $this->filter('_' . $collectionDoc->getSequence() . '_' . $relatedCollectionDoc->getSequence())
-                    : $this->getNamespace() . '_' . $this->filter('_' . $relatedCollectionDoc->getSequence() . '_' . $collectionDoc->getSequence());
+                $junction = $relationship->side === RelationSide::Parent
+                    ? $this->getNamespace().'_'.$this->filter('_'.$collectionDoc->getSequence().'_'.$relatedCollectionDoc->getSequence())
+                    : $this->getNamespace().'_'.$this->filter('_'.$relatedCollectionDoc->getSequence().'_'.$collectionDoc->getSequence());
 
-                if (!\is_null($newKey) && $key !== $newKey) {
+                if (! \is_null($newKey) && $relationship->key !== $newKey) {
                     $this->getClient()->update($junction, updates: $renameKey, multi: true);
                 }
-                if ($twoWay && !\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+                if ($relationship->twoWay && ! \is_null($newTwoWayKey) && $relationship->twoWayKey !== $newTwoWayKey) {
                     $this->getClient()->update($junction, updates: $renameTwoWayKey, multi: true);
                 }
                 break;
@@ -924,71 +1000,57 @@ public function updateRelationship(
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @return bool
      * @throws MongoException
      * @throws Exception
      */
     public function deleteRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side
+        Relationship $relationship
     ): bool {
-        $collectionName = $this->getNamespace() . '_' . $this->filter($collection);
-        $relatedCollectionName = $this->getNamespace() . '_' . $this->filter($relatedCollection);
-        $escapedKey = $this->escapeMongoFieldName($key);
-        $escapedTwoWayKey = $this->escapeMongoFieldName($twoWayKey);
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+        $collectionName = $this->getNamespace().'_'.$this->filter($relationship->collection);
+        $relatedCollectionName = $this->getNamespace().'_'.$this->filter($relationship->relatedCollection);
+        $escapedKey = $this->escapeMongoFieldName($relationship->key);
+        $escapedTwoWayKey = $this->escapeMongoFieldName($relationship->twoWayKey);
+
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($relationship->side === RelationSide::Parent) {
                     $this->getClient()->update($collectionName, [], ['$unset' => [$escapedKey => '']], multi: true);
-                    if ($twoWay) {
+                    if ($relationship->twoWay) {
                         $this->getClient()->update($relatedCollectionName, [], ['$unset' => [$escapedTwoWayKey => '']], multi: true);
                     }
-                } elseif ($side === Database::RELATION_SIDE_CHILD) {
+                } elseif ($relationship->side === RelationSide::Child) {
                     $this->getClient()->update($relatedCollectionName, [], ['$unset' => [$escapedTwoWayKey => '']], multi: true);
-                    if ($twoWay) {
+                    if ($relationship->twoWay) {
                         $this->getClient()->update($collectionName, [], ['$unset' => [$escapedKey => '']], multi: true);
                     }
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+            case RelationType::OneToMany:
+                if ($relationship->side === RelationSide::Parent) {
                     $this->getClient()->update($relatedCollectionName, [], ['$unset' => [$escapedTwoWayKey => '']], multi: true);
                 } else {
                     $this->getClient()->update($collectionName, [], ['$unset' => [$escapedKey => '']], multi: true);
                 }
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+            case RelationType::ManyToOne:
+                if ($relationship->side === RelationSide::Parent) {
                     $this->getClient()->update($collectionName, [], ['$unset' => [$escapedKey => '']], multi: true);
                 } else {
                     $this->getClient()->update($relatedCollectionName, [], ['$unset' => [$escapedTwoWayKey => '']], multi: true);
                 }
                 break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collectionDoc = $this->getDocument($metadataCollection, $collection);
-                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collectionDoc = $this->getDocument($metadataCollection, $relationship->collection);
+                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relationship->relatedCollection);
 
                 if ($collectionDoc->isEmpty() || $relatedCollectionDoc->isEmpty()) {
                     throw new DatabaseException('Collection or related collection not found');
                 }
 
-                $junction = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getNamespace() . '_' . $this->filter('_' . $collectionDoc->getSequence() . '_' . $relatedCollectionDoc->getSequence())
-                    : $this->getNamespace() . '_' . $this->filter('_' . $relatedCollectionDoc->getSequence() . '_' . $collectionDoc->getSequence());
+                $junction = $relationship->side === RelationSide::Parent
+                    ? $this->getNamespace().'_'.$this->filter('_'.$collectionDoc->getSequence().'_'.$relatedCollectionDoc->getSequence())
+                    : $this->getNamespace().'_'.$this->filter('_'.$relatedCollectionDoc->getSequence().'_'.$collectionDoc->getSequence());
 
                 $this->getClient()->dropCollection($junction);
                 break;
@@ -1002,34 +1064,36 @@ public function deleteRelationship(
     /**
      * Create Index
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param array<string, string> $indexAttributeTypes
-     * @param array<string, mixed> $collation
-     * @param int $ttl
-     * @return bool
+     * @param  array<string, string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
+     *
      * @throws Exception
      */
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-        $id = $this->filter($id);
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
+    {
+        $name = $this->getNamespace().'_'.$this->filter($collection);
+        $id = $this->filter($index->key);
+        $type = $index->type;
+        $attributes = $index->attributes;
+        $orders = $index->orders;
+        $ttl = $index->ttl;
+        /** @var array<string, mixed> $indexes */
         $indexes = [];
         $options = [];
         $indexes['name'] = $id;
 
+        /** @var array<string, int|string> $indexKey */
+        $indexKey = [];
+
         // If sharedTables, always add _tenant as the first key
         if ($this->shouldAddTenantToIndex($type)) {
-            $indexes['key']['_tenant'] = $this->getOrder(Database::ORDER_ASC);
+            $indexKey[Storage::TENANT] = $this->getOrder(OrderDirection::Asc);
         }
 
         foreach ($attributes as $i => $attribute) {
+            $attribute = (string) $attribute;
 
-            if (isset($indexAttributeTypes[$attribute]) && \str_contains($attribute, '.') && $indexAttributeTypes[$attribute] === Database::VAR_OBJECT) {
+            if (isset($indexAttributeTypes[$attribute]) && \str_contains($attribute, '.') && $indexAttributeTypes[$attribute] === ColumnType::Object->value) {
                 $dottedAttributes = \explode('.', $attribute);
                 $expandedAttributes = array_map(fn ($attr) => $this->filter($attr), $dottedAttributes);
                 $attributes[$i] = implode('.', $expandedAttributes);
@@ -1037,33 +1101,35 @@ public function createIndex(string $collection, string $id, string $type, array
                 $attributes[$i] = $this->filter($this->getInternalKeyForAttribute($attribute));
             }
 
-            $orderType = $this->getOrder($this->filter($orders[$i] ?? Database::ORDER_ASC));
-            $indexes['key'][$attributes[$i]] = $orderType;
+            $orderType = $this->getOrder(OrderDirection::tryFrom(Index::direction($orders[$i] ?? null)) ?? OrderDirection::Asc);
+            $indexKey[$attributes[$i]] = $orderType;
 
             switch ($type) {
-                case Database::INDEX_KEY:
+                case IndexType::Key:
                     break;
-                case Database::INDEX_FULLTEXT:
-                    $indexes['key'][$attributes[$i]] = 'text';
+                case IndexType::Fulltext:
+                    $indexKey[$attributes[$i]] = 'text';
                     break;
-                case Database::INDEX_UNIQUE:
+                case IndexType::Unique:
                     $indexes['unique'] = true;
                     break;
-                case Database::INDEX_TTL:
+                case IndexType::Ttl:
                     break;
                 default:
                     return false;
             }
         }
 
+        $indexes['key'] = $indexKey;
+
         /**
          * Collation
          *  1.  Moved under $indexes.
          *  2.  Updated format.
          *  3.  Avoid adding collation to fulltext index
          */
-        if (!empty($collation) &&
-            $type !== Database::INDEX_FULLTEXT) {
+        if (! empty($collation) &&
+            $type !== IndexType::Fulltext) {
             $indexes['collation'] = [
                 'locale' => 'en',
                 'strength' => 1,
@@ -1075,24 +1141,24 @@ public function createIndex(string $collection, string $id, string $type, array
          * Set to 'none' to disable stop words (words like 'other', 'the', 'a', etc.)
          * This ensures all words are indexed and searchable
          */
-        if ($type === Database::INDEX_FULLTEXT) {
+        if ($type === IndexType::Fulltext) {
             $indexes['default_language'] = 'none';
         }
 
         // Handle TTL indexes
-        if ($type === Database::INDEX_TTL && $ttl > 0) {
+        if ($type === IndexType::Ttl && $ttl > 0) {
             $indexes['expireAfterSeconds'] = $ttl;
         }
 
         // Add partial filter for indexes to avoid indexing null values
-        if (in_array($type, [Database::INDEX_UNIQUE, Database::INDEX_KEY])) {
+        if (in_array($type, [IndexType::Unique, IndexType::Key])) {
             $partialFilter = [];
             foreach ($attributes as $i => $attr) {
-                $attrType = $indexAttributeTypes[$i] ?? Database::VAR_STRING; // Default to string if type not provided
+                $attrType = Attribute::tryNormalizeType($indexAttributeTypes[$i] ?? '') ?? ColumnType::String;
                 $attrType = $this->getMongoTypeCode($attrType);
                 $partialFilter[$attr] = ['$exists' => true, '$type' => $attrType];
             }
-            if (!empty($partialFilter)) {
+            if (! empty($partialFilter)) {
                 $indexes['partialFilterExpression'] = $partialFilter;
             }
         }
@@ -1102,7 +1168,7 @@ public function createIndex(string $collection, string $id, string $type, array
             // Wait for unique index to be fully built before returning
             // MongoDB builds indexes asynchronously, so we need to wait for completion
             // to ensure unique constraints are enforced immediately
-            if ($type === Database::INDEX_UNIQUE) {
+            if ($type === IndexType::Unique) {
                 $maxRetries = 10;
                 $retryCount = 0;
                 $baseDelay = 50000; // 50ms
@@ -1110,26 +1176,31 @@ public function createIndex(string $collection, string $id, string $type, array
 
                 while ($retryCount < $maxRetries) {
                     try {
+                        /** @var \stdClass $indexList */
                         $indexList = $this->client->query([
-                            'listIndexes' => $name
+                            'listIndexes' => $name,
                         ]);
 
-                        if (isset($indexList->cursor->firstBatch)) {
-                            foreach ($indexList->cursor->firstBatch as $existingIndex) {
+                        /** @var \stdClass $indexListCursor */
+                        $indexListCursor = $indexList->cursor;
+                        if (isset($indexListCursor->firstBatch)) {
+                            /** @var array<mixed> $firstBatch */
+                            $firstBatch = $indexListCursor->firstBatch;
+                            foreach ($firstBatch as $existingIndex) {
                                 $indexArray = $this->client->toArray($existingIndex);
 
                                 if (
                                     (isset($indexArray['name']) && $indexArray['name'] === $id) &&
-                                    (!isset($indexArray['buildState']) || $indexArray['buildState'] === 'ready')
+                                    (! isset($indexArray['buildState']) || $indexArray['buildState'] === 'ready')
                                 ) {
                                     return $result;
                                 }
                             }
                         }
-                    } catch (\Exception $e) {
+                    } catch (Exception $e) {
                         if ($retryCount >= $maxRetries - 1) {
                             throw new DatabaseException(
-                                'Timeout waiting for index creation: ' . $e->getMessage(),
+                                'Timeout waiting for index creation: '.$e->getMessage(),
                                 $e->getCode(),
                                 $e
                             );
@@ -1137,7 +1208,7 @@ public function createIndex(string $collection, string $id, string $type, array
                     }
 
                     $delay = \min($baseDelay * (2 ** $retryCount), $maxDelay);
-                    \usleep((int)$delay);
+                    \usleep((int) $delay);
                     $retryCount++;
                 }
 
@@ -1145,33 +1216,50 @@ public function createIndex(string $collection, string $id, string $type, array
             }
 
             return $result;
-        } catch (\Exception $e) {
+        } catch (Exception $e) {
             throw $this->processException($e);
         }
     }
 
+    /**
+     * Delete Index
+     *
+     *
+     * @throws Exception
+     */
+    public function deleteIndex(string $collection, string $id): bool
+    {
+        $name = $this->getNamespace().'_'.$this->filter($collection);
+        $id = $this->filter($id);
+        $this->getClient()->dropIndexes($name, [$id]);
+
+        return true;
+    }
+
     /**
      * Rename Index.
      *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
      *
-     * @return bool
      * @throws Exception
      */
     public function renameIndex(string $collection, string $old, string $new): bool
     {
         $collection = $this->filter($collection);
-        $metadataCollection = new Document(['$id' => Database::METADATA]);
+        $metadataCollection = new Document([Document::ID => Database::METADATA]);
         $collectionDocument = $this->getDocument($metadataCollection, $collection);
         $old = $this->filter($old);
         $new = $this->filter($new);
-        $indexes = json_decode($collectionDocument['indexes'], true);
+        $rawIndexes = $collectionDocument->getAttribute('indexes', '[]');
+        /** @var array<int, array<string, mixed>> $indexes */
+        $indexes = json_decode((string) (is_string($rawIndexes) ? $rawIndexes : '[]'), true) ?? [];
+        /** @var array<string, mixed>|null $index */
         $index = null;
 
         foreach ($indexes as $node) {
-            if (($node['$id'] ?? $node['key'] ?? '') === $old) {
+            /** @var array<string, mixed> $node */
+            $nodeId = $node[Document::ID] ?? $node['key'] ?? '';
+            $nodeIdStr = \is_string($nodeId) ? $nodeId : (\is_scalar($nodeId) ? (string) $nodeId : '');
+            if ($nodeIdStr === $old) {
                 $index = $node;
                 break;
             }
@@ -1179,14 +1267,22 @@ public function renameIndex(string $collection, string $old, string $new): bool
 
         // Extract attribute types from the collection document
         $indexAttributeTypes = [];
-        if (isset($collectionDocument['attributes'])) {
-            $attributes = json_decode($collectionDocument['attributes'], true);
+        $rawAttributes = $collectionDocument->getAttribute('attributes');
+        if ($rawAttributes !== null) {
+            /** @var array<int, array<string, mixed>> $attributes */
+            $attributes = json_decode((string) (is_string($rawAttributes) ? $rawAttributes : '[]'), true) ?? [];
             if ($attributes && $index) {
                 // Map index attributes to their types
-                foreach ($index['attributes'] as $attrName) {
+                /** @var array<string> $indexAttrs */
+                $indexAttrs = $index['attributes'] ?? [];
+                foreach ($indexAttrs as $attrName) {
                     foreach ($attributes as $attr) {
-                        if ($attr['key'] === $attrName) {
-                            $indexAttributeTypes[$attrName] = $attr['type'];
+                        /** @var array<string, mixed> $attr */
+                        $attrKey = $attr['key'] ?? '';
+                        $attrKeyStr = \is_string($attrKey) ? $attrKey : (\is_scalar($attrKey) ? (string) $attrKey : '');
+                        if ($attrKeyStr === $attrName) {
+                            $attrType = $attr['type'] ?? '';
+                            $indexAttributeTypes[$attrName] = \is_string($attrType) ? $attrType : (\is_scalar($attrType) ? (string) $attrType : '');
                             break;
                         }
                     }
@@ -1195,12 +1291,27 @@ public function renameIndex(string $collection, string $old, string $new): bool
         }
 
         try {
-            if (!$index) {
-                throw new DatabaseException('Index not found: ' . $old);
+            if (! $index) {
+                throw new DatabaseException('Index not found: '.$old);
             }
             $deletedindex = $this->deleteIndex($collection, $old);
-            $createdindex = $this->createIndex($collection, $new, $index['type'], $index['attributes'], $index['lengths'] ?? [], $index['orders'] ?? [], $indexAttributeTypes, [], $index['ttl'] ?? 0);
-        } catch (\Exception $e) {
+            /** @var array<string> $indexAttributes */
+            $indexAttributes = $index['attributes'] ?? [];
+            /** @var array<int> $indexLengths */
+            $indexLengths = $index['lengths'] ?? [];
+            $rawIndexType = $index['type'] ?? 'key';
+            $indexTypeStr = \is_string($rawIndexType) ? $rawIndexType : (\is_scalar($rawIndexType) ? (string) $rawIndexType : 'key');
+            $rawIndexTtl = $index['ttl'] ?? 0;
+            $indexTtlInt = \is_int($rawIndexTtl) ? $rawIndexTtl : (\is_numeric($rawIndexTtl) ? (int) $rawIndexTtl : 0);
+            $createdindex = $this->createIndex($collection, Index::fromArray([
+                'key' => $new,
+                'type' => $indexTypeStr,
+                'attributes' => $indexAttributes,
+                'lengths' => $indexLengths,
+                'orders' => $index['orders'] ?? [],
+                'ttl' => $indexTtlInt,
+            ]), $indexAttributeTypes);
+        } catch (Exception $e) {
             throw $this->processException($e);
         }
 
@@ -1211,56 +1322,37 @@ public function renameIndex(string $collection, string $old, string $new): bool
         return false;
     }
 
-    /**
-     * Delete Index
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     * @throws Exception
-     */
-    public function deleteIndex(string $collection, string $id): bool
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-        $id = $this->filter($id);
-        $this->getClient()->dropIndexes($name, [$id]);
-
-        return true;
-    }
-
     /**
      * Get Document
      *
-     * @param Document $collection
-     * @param string $id
-     * @param Query[] $queries
-     * @param bool $forUpdate
-     * @return Document
+     * @param  Query[]  $queries
+     *
      * @throws DatabaseException
      */
     public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
-        $filters = ['_uid' => $id];
-
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
+        $filters = [Storage::UID => $id];
 
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
 
         $options = $this->getTransactionOptions();
 
         $selections = $this->getAttributeSelections($queries);
-        $hasProjection = !empty($selections) && !\in_array('*', $selections);
+        $hasProjection = ! empty($selections) && ! \in_array('*', $selections);
 
         if ($hasProjection) {
             $options['projection'] = $this->getAttributeProjection($selections);
         }
 
         try {
-            $result = $this->client->find($name, $filters, $options)->cursor->firstBatch;
+            $findResponse = $this->client->find($name, $filters, $options);
+            /** @var \stdClass $findCursor */
+            $findCursor = $findResponse->cursor;
+            /** @var array<mixed> $result */
+            $result = $findCursor->firstBatch;
         } catch (MongoException $e) {
             throw $this->processException($e);
         }
@@ -1269,13 +1361,14 @@ public function getDocument(Document $collection, string $id, array $queries = [
             return new Document([]);
         }
 
+        /** @var array<string, mixed>|null $resultArray */
         $resultArray = $this->client->toArray($result[0]);
-        $result = $this->replaceChars('_', '$', $resultArray);
+        $result = $this->replaceChars('_', '$', $resultArray ?? []);
         $document = new Document($result);
         $document = $this->castingAfter($collection, $document);
 
         // Ensure missing relationship attributes are set to null (MongoDB doesn't store null fields)
-        if (!$hasProjection) {
+        if (! $hasProjection) {
             $this->ensureRelationshipDefaults($collection, $document);
         }
 
@@ -1285,29 +1378,27 @@ public function getDocument(Document $collection, string $id, array $queries = [
     /**
      * Create Document
      *
-     * @param Document $collection
-     * @param Document $document
      *
-     * @return Document
      * @throws Exception
      */
     public function createDocument(Document $collection, Document $document): Document
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $this->syncWriteHooks();
 
-        $sequence = $document->getSequence();
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
-        $document->removeAttribute('$sequence');
+        $sequence = $document->getSequence();
 
-        if ($this->sharedTables) {
-            $document->setAttribute('$tenant', $this->getTenant());
-        }
+        $document->removeAttribute(Document::SEQUENCE);
 
-        $record = $this->replaceChars('$', '_', (array)$document);
+        /** @var array<string, mixed> $documentArray */
+        $documentArray = (array) $document;
+        $record = $this->replaceChars('$', '_', $documentArray);
+        $record = $this->decorateRow($record, $this->documentMetadata($document));
 
         // Insert manual id if set
-        if (!empty($sequence)) {
-            $record['_id'] = $sequence;
+        if (! empty($sequence)) {
+            $record[Storage::SEQUENCE] = $sequence;
         }
         $options = $this->getTransactionOptions();
         $result = $this->insertDocument($name, $this->removeNullKeys($record), $options);
@@ -1320,203 +1411,10 @@ public function createDocument(Document $collection, Document $document): Docume
         return $document;
     }
 
-    /**
-     * Returns the document after casting from
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     */
-    public function castingAfter(Document $collection, Document $document): Document
-    {
-        if (!$this->getSupportForInternalCasting()) {
-            return $document;
-        }
-
-        if ($document->isEmpty()) {
-            return $document;
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $attributes = \array_merge($attributes, Database::INTERNAL_ATTRIBUTES);
-
-        foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            $type = $attribute['type'] ?? '';
-            $array = $attribute['array'] ?? false;
-            $value = $document->getAttribute($key);
-            if (is_null($value)) {
-                continue;
-            }
-
-            // Operators are resolved by the database (aggregation pipeline); skip casting
-            if (Operator::isOperator($value)) {
-                continue;
-            }
-
-            if ($array) {
-                if (is_string($value)) {
-                    $decoded = json_decode($value, true);
-                    if (json_last_error() !== JSON_ERROR_NONE) {
-                        throw new DatabaseException('Failed to decode JSON for attribute ' . $key . ': ' . json_last_error_msg());
-                    }
-                    $value = $decoded;
-                }
-            } else {
-                $value = [$value];
-            }
-
-            foreach ($value as &$node) {
-                switch ($type) {
-                    case Database::VAR_INTEGER:
-                    case Database::VAR_BIGINT:
-                        $node = (int)$node;
-                        break;
-                    case Database::VAR_DATETIME:
-                        $node = $this->convertUTCDateToString($node);
-                        break;
-                    case Database::VAR_OBJECT:
-                        // Convert stdClass objects to arrays for object attributes
-                        if (is_object($node) && get_class($node) === stdClass::class) {
-                            $node = $this->convertStdClassToArray($node);
-                        }
-                        break;
-                    default:
-                        break;
-                }
-            }
-            unset($node);
-            $document->setAttribute($key, ($array) ? $value : $value[0]);
-        }
-
-        if (!$this->getSupportForAttributes()) {
-            foreach ($document->getArrayCopy() as $key => $value) {
-                // mongodb results out a stdclass for objects
-                if (is_object($value) && get_class($value) === stdClass::class) {
-                    $document->setAttribute($key, $this->convertStdClassToArray($value));
-                } elseif ($value instanceof UTCDateTime) {
-                    $document->setAttribute($key, $this->convertUTCDateToString($value));
-                }
-            }
-        }
-        return $document;
-    }
-
-    private function convertStdClassToArray(mixed $value): mixed
-    {
-        if (is_object($value) && get_class($value) === stdClass::class) {
-            $properties = get_object_vars($value);
-
-            return $properties === [] ? $value : array_map($this->convertStdClassToArray(...), $properties);
-        }
-
-        if (is_array($value)) {
-            return array_map(
-                fn ($v) => $this->convertStdClassToArray($v),
-                $value
-            );
-        }
-
-        return $value;
-    }
-
-    /**
-     * Returns the document after casting to
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     * @throws Exception
-     */
-    public function castingBefore(Document $collection, Document $document): Document
-    {
-        if (!$this->getSupportForInternalCasting()) {
-            return $document;
-        }
-
-        if ($document->isEmpty()) {
-            return $document;
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $attributes = \array_merge($attributes, Database::INTERNAL_ATTRIBUTES);
-
-        foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            $type = $attribute['type'] ?? '';
-            $array = $attribute['array'] ?? false;
-
-            $value = $document->getAttribute($key);
-            if (is_null($value)) {
-                continue;
-            }
-
-            // Operators are resolved by the database (aggregation pipeline); skip casting
-            if (Operator::isOperator($value)) {
-                continue;
-            }
-
-            if ($array) {
-                if (is_string($value)) {
-                    $decoded = json_decode($value, true);
-                    if (json_last_error() !== JSON_ERROR_NONE) {
-                        throw new DatabaseException('Failed to decode JSON for attribute ' . $key . ': ' . json_last_error_msg());
-                    }
-                    $value = $decoded;
-                }
-            } else {
-                $value = [$value];
-            }
-
-            foreach ($value as &$node) {
-                switch ($type) {
-                    case Database::VAR_DATETIME:
-                        if (!($node instanceof UTCDateTime)) {
-                            try {
-                                $node = new UTCDateTime(new \DateTime($node));
-                            } catch (\Throwable $e) {
-                                throw new StructureException('Invalid datetime value for attribute "' . $key . '": ' . $e->getMessage());
-                            }
-                        }
-                        break;
-                    case Database::VAR_OBJECT:
-                        $node = json_decode($node);
-                        break;
-                    default:
-                        break;
-                }
-            }
-            unset($node);
-            $document->setAttribute($key, ($array) ? $value : $value[0]);
-        }
-        $indexes = $collection->getAttribute('indexes');
-        $ttlIndexes = array_filter($indexes, fn ($index) => $index->getAttribute('type') === Database::INDEX_TTL);
-
-        if (!$this->getSupportForAttributes()) {
-            foreach ($document->getArrayCopy() as $key => $value) {
-                if (in_array($this->getInternalKeyForAttribute($key), Database::INTERNAL_ATTRIBUTE_KEYS)) {
-                    continue;
-                }
-                if (is_string($value) && (in_array($key, $ttlIndexes) || $this->isExtendedISODatetime($value))) {
-                    try {
-                        $newValue = new UTCDateTime(new \DateTime($value));
-                        $document->setAttribute($key, $newValue);
-                    } catch (\Throwable $th) {
-                        // skip -> a valid string
-                    }
-                }
-            }
-        }
-
-        return $document;
-    }
-
     /**
      * Create Documents in batches
      *
-     * @param Document $collection
-     * @param array<Document> $documents
-     *
+     * @param  array<Document>  $documents
      * @return array<Document>
      *
      * @throws DuplicateException
@@ -1524,7 +1422,9 @@ public function castingBefore(Document $collection, Document $document): Documen
      */
     public function createDocuments(Document $collection, array $documents): array
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $this->syncWriteHooks();
+
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         $options = $this->getTransactionOptions();
         $records = [];
@@ -1535,15 +1435,18 @@ public function createDocuments(Document $collection, array $documents): array
             $sequence = $document->getSequence();
 
             if ($hasSequence === null) {
-                $hasSequence = !empty($sequence);
+                $hasSequence = ! empty($sequence);
             } elseif ($hasSequence == empty($sequence)) {
                 throw new DatabaseException('All documents must have an sequence if one is set');
             }
 
-            $record = $this->replaceChars('$', '_', (array)$document);
+            /** @var array<string, mixed> $documentArr */
+            $documentArr = (array) $document;
+            $record = $this->replaceChars('$', '_', $documentArr);
+            $record = $this->decorateRow($record, $this->documentMetadata($document));
 
-            if (!empty($sequence)) {
-                $record['_id'] = $sequence;
+            if (! empty($sequence)) {
+                $record[Storage::SEQUENCE] = $sequence;
             }
 
             $records[] = $record;
@@ -1557,14 +1460,14 @@ public function createDocuments(Document $collection, array $documents): array
 
             $operations = [];
             foreach ($records as $record) {
-                $filter = ['_uid' => $record['_uid'] ?? ''];
+                $filter = [Storage::UID => $record[Storage::UID] ?? ''];
                 if ($this->sharedTables) {
-                    $filter['_tenant'] = $record['_tenant'] ?? $this->getTenant();
+                    $filter[Storage::TENANT] = $record[Storage::TENANT] ?? $this->getTenant();
                 }
 
                 // Filter fields can't reappear in $setOnInsert (mongo path-conflict error).
                 $setOnInsert = $record;
-                unset($setOnInsert['_uid'], $setOnInsert['_tenant']);
+                unset($setOnInsert[Storage::UID], $setOnInsert[Storage::TENANT]);
 
                 if (empty($setOnInsert)) {
                     continue;
@@ -1592,7 +1495,9 @@ public function createDocuments(Document $collection, array $documents): array
         }
 
         foreach ($documents as $index => $document) {
-            $documents[$index] = $this->replaceChars('_', '$', $this->client->toArray($document));
+            /** @var array<string, mixed> $toArrayResult */
+            $toArrayResult = $this->client->toArray($document) ?? [];
+            $documents[$index] = $this->replaceChars('_', '$', $toArrayResult);
             $documents[$index] = new Document($documents[$index]);
         }
 
@@ -1600,69 +1505,25 @@ public function createDocuments(Document $collection, array $documents): array
     }
 
     /**
+     * Update Document
      *
-     * @param string $name
-     * @param array<string, mixed> $document
-     * @param array<string, mixed> $options
-     *
-     * @return array<string, mixed>
      * @throws DuplicateException
-     * @throws Exception
+     * @throws DatabaseException
      */
-    private function insertDocument(string $name, array $document, array $options = []): array
+    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        try {
-            $result = $this->client->insert($name, $document, $options);
-            $filters = [];
-            $filters['_uid'] = $document['_uid'];
-
-            if ($this->sharedTables) {
-                $filters['_tenant'] = $this->getTenantFilters($name);
-            }
-
-            try {
-                $result = $this->client->find(
-                    $name,
-                    $filters,
-                    array_merge(['limit' => 1], $options)
-                )->cursor->firstBatch[0];
-            } catch (MongoException $e) {
-                throw $this->processException($e);
-            }
-
-            return $this->client->toArray($result);
-        } catch (MongoException $e) {
-            throw $this->processException($e);
-        }
-    }
-
-    /**
-     * Update Document
-     *
-     * @param Document $collection
-     * @param string $id
-     * @param Document $document
-     * @param bool $skipPermissions
-     * @return Document
-     * @throws DuplicateException
-     * @throws DatabaseException
-     */
-    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         $record = $document->getArrayCopy();
         $record = $this->replaceChars('$', '_', $record);
 
-        $filters = [];
-        $filters['_uid'] = $id;
+        $filters = [Storage::UID => $id];
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
 
         try {
-            unset($record['_id']); // Don't update _id
+            unset($record[Storage::SEQUENCE]); // Don't update _id
 
             $options = $this->getTransactionOptions();
 
@@ -1687,40 +1548,42 @@ public function updateDocument(Document $collection, string $id, Document $docum
      *
      * Updates all documents which match the given query.
      *
-     * @param Document $collection
-     * @param Document $updates
-     * @param array<Document> $documents
-     *
-     * @return int
+     * @param  array<Document>  $documents
      *
      * @throws DatabaseException
      */
     public function updateDocuments(Document $collection, Document $updates, array $documents): int
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         $options = $this->getTransactionOptions();
         $queries = [
-            Query::equal('$sequence', \array_map(fn ($document) => $document->getSequence(), $documents))
+            Query::equal(Document::SEQUENCE, \array_map(fn ($document) => $document->getSequence(), $documents)),
         ];
 
+        /** @var array<string, mixed> $filters */
         $filters = $this->buildFilters($queries);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
 
         $record = $updates->getArrayCopy();
         $record = $this->replaceChars('$', '_', $record);
+        unset($record[Storage::VERSION]);
 
         try {
             $pipeline = $this->buildOperatorPipeline($record);
             if ($pipeline !== null) {
+                $pipeline[0]['$set'][Storage::VERSION] = [
+                    '$add' => [['$ifNull' => ['$' . Storage::VERSION, 0]], 1],
+                ];
+
                 return $this->updateWithPipeline($name, $filters, $pipeline, $options, multi: true);
             }
 
             $updateQuery = [
                 '$set' => $record,
+                '$inc' => [Storage::VERSION => 1],
             ];
 
             return $this->client->update(
@@ -1736,72 +1599,60 @@ public function updateDocuments(Document $collection, Document $updates, array $
     }
 
     /**
-     * Build an aggregation pipeline update from a record that may contain Operator instances.
+     * Build an aggregation pipeline update from a record containing operators.
      *
-     * Returns null when the record contains no operators, so the caller can fall back to a
-     * plain `$set` update. When operators are present, every regular value is wrapped in
-     * `$literal` (so it is never interpreted as an aggregation expression) and every operator
-     * is translated into the equivalent aggregation expression, all merged into a single
-     * `$set` stage.
+     * @param  array<string, mixed>  $record
+     * @return array{0: array{'$set': array<string, mixed>}}|null
      *
-     * @param array<string, mixed> $record
-     * @return array<int, array<string, mixed>>|null
      * @throws DatabaseException
      */
     private function buildOperatorPipeline(array $record): ?array
     {
         $hasOperators = false;
         foreach ($record as $value) {
-            if (Operator::isOperator($value)) {
+            if ($value instanceof Operator) {
                 $hasOperators = true;
+
                 break;
             }
         }
 
-        if (!$hasOperators) {
+        if (! $hasOperators) {
             return null;
         }
 
         $set = [];
         foreach ($record as $key => $value) {
-            if (Operator::isOperator($value)) {
-                $set[$key] = $this->getOperatorExpression($value, $key);
-            } else {
-                // Wrap literals so values are never parsed as aggregation expressions/field paths
-                $set[$key] = ['$literal' => $value];
-            }
+            $set[$key] = $value instanceof Operator
+                ? $this->getOperatorExpression($value, $key)
+                : ['$literal' => $value];
         }
 
         return [['$set' => $set]];
     }
 
     /**
-     * Execute an aggregation pipeline update.
-     *
-     * The Mongo client's update() helper wraps the update document in toObject(), which would
-     * turn a pipeline (a list) into an object and break it. We therefore build the raw update
-     * command and send it through query(), letting BSON encode the pipeline as an array.
+     * @param  array<string, mixed>  $filters
+     * @param  array<int, array<string, mixed>>  $pipeline
+     * @param  array<string, mixed>  $options
      *
-     * @param string $collection
-     * @param array<string, mixed> $filters
-     * @param array<int, array<string, mixed>> $pipeline
-     * @param array<string, mixed> $options
-     * @param bool $multi
-     * @return int Number of matched documents
      * @throws MongoException
      */
-    private function updateWithPipeline(string $collection, array $filters, array $pipeline, array $options = [], bool $multi = false): int
-    {
+    private function updateWithPipeline(
+        string $collection,
+        array $filters,
+        array $pipeline,
+        array $options = [],
+        bool $multi = false,
+    ): int {
         $command = [
             'update' => $collection,
-            'updates' => [
-                [
-                    'q' => $this->client->toObject($filters),
-                    'u' => $pipeline,
-                    'multi' => $multi,
-                    'upsert' => false,
-                ],
-            ],
+            'updates' => [[
+                'q' => $this->client->toObject($filters),
+                'u' => $pipeline,
+                'multi' => $multi,
+                'upsert' => false,
+            ]],
         ];
 
         if (isset($options['session'])) {
@@ -1814,103 +1665,82 @@ private function updateWithPipeline(string $collection, array $filters, array $p
     }
 
     /**
-     * Execute a batch of upsert operations, supporting aggregation-pipeline updates.
-     *
-     * Mirrors the Mongo client's upsert() helper but does not wrap each update in toObject(),
-     * so an update may be either a classic update document or an aggregation pipeline (list).
+     * @param  array<int, array{filter: array<string, mixed>, update: array<mixed>}>  $operations
+     * @param  array<string, mixed>  $options
      *
-     * @param string $collection
-     * @param array<int, array{filter: array<string, mixed>, update: array<mixed>}> $operations
-     * @param array<string, mixed> $options
-     * @return int
      * @throws MongoException
      */
     private function executeUpsert(string $collection, array $operations, array $options = []): int
     {
         $updates = [];
-        foreach ($operations as $op) {
+        foreach ($operations as $operation) {
             $updates[] = [
-                'q' => $this->client->toObject($op['filter']),
-                'u' => $op['update'],
+                'q' => $this->client->toObject($operation['filter']),
+                'u' => $operation['update'],
                 'upsert' => true,
                 'multi' => false,
             ];
         }
 
-        $command = \array_merge(
-            [
-                'update' => $collection,
-                'updates' => $updates,
-            ],
-            $options
-        );
-
-        $result = $this->client->query($command);
+        $result = $this->client->query(\array_merge([
+            'update' => $collection,
+            'updates' => $updates,
+        ], $options));
 
         return \is_int($result) ? $result : 0;
     }
 
     /**
-     * Translate an Operator into a MongoDB aggregation expression for use inside a `$set` stage.
-     *
-     * @param Operator $operator
-     * @param string $field The (already escaped) field name the expression is assigned to
-     * @return mixed
      * @throws DatabaseException
      */
     private function getOperatorExpression(Operator $operator, string $field): mixed
     {
-        $ref = '$' . $field;
+        $reference = '$'.$field;
         $method = $operator->getMethod();
         $values = $operator->getValues();
 
         switch ($method) {
-            // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                $expr = ['$add' => [['$ifNull' => [$ref, 0]], $values[0] ?? 1]];
+            case OperatorType::Increment:
+                $expression = ['$add' => [['$ifNull' => [$reference, 0]], $values[0] ?? 1]];
                 if (isset($values[1])) {
-                    $expr = ['$cond' => [['$lte' => [$expr, $values[1]]], $expr, ['$ifNull' => [$ref, 0]]]];
+                    $expression = ['$cond' => [['$lte' => [$expression, $values[1]]], $expression, ['$ifNull' => [$reference, 0]]]];
                 }
-                return $expr;
 
-            case Operator::TYPE_DECREMENT:
-                $expr = ['$subtract' => [['$ifNull' => [$ref, 0]], $values[0] ?? 1]];
+                return $expression;
+
+            case OperatorType::Decrement:
+                $expression = ['$subtract' => [['$ifNull' => [$reference, 0]], $values[0] ?? 1]];
                 if (isset($values[1])) {
-                    $expr = ['$cond' => [['$gte' => [$expr, $values[1]]], $expr, ['$ifNull' => [$ref, 0]]]];
+                    $expression = ['$cond' => [['$gte' => [$expression, $values[1]]], $expression, ['$ifNull' => [$reference, 0]]]];
                 }
-                return $expr;
 
-            case Operator::TYPE_MULTIPLY:
-                $expr = ['$multiply' => [['$ifNull' => [$ref, 0]], $values[0] ?? 1]];
+                return $expression;
+
+            case OperatorType::Multiply:
+                $expression = ['$multiply' => [['$ifNull' => [$reference, 0]], $values[0] ?? 1]];
                 if (isset($values[1])) {
-                    $expr = ['$cond' => [['$lte' => [$expr, $values[1]]], $expr, ['$ifNull' => [$ref, 0]]]];
+                    $expression = ['$cond' => [['$lte' => [$expression, $values[1]]], $expression, ['$ifNull' => [$reference, 0]]]];
                 }
-                return $expr;
 
-            case Operator::TYPE_DIVIDE:
-                $expr = ['$divide' => [['$ifNull' => [$ref, 0]], $values[0]]];
+                return $expression;
+
+            case OperatorType::Divide:
+                $expression = ['$divide' => [['$ifNull' => [$reference, 0]], $values[0]]];
                 if (isset($values[1])) {
-                    $expr = ['$cond' => [['$gte' => [$expr, $values[1]]], $expr, ['$ifNull' => [$ref, 0]]]];
+                    $expression = ['$cond' => [['$gte' => [$expression, $values[1]]], $expression, ['$ifNull' => [$reference, 0]]]];
                 }
-                return $expr;
 
-            case Operator::TYPE_MODULO:
-                return ['$mod' => [['$ifNull' => [$ref, 0]], $values[0]]];
+                return $expression;
 
-            case Operator::TYPE_POWER:
-                $base = ['$ifNull' => [$ref, 0]];
-                $exponent = $values[0];
-                $expr = ['$pow' => [$base, $exponent]];
+            case OperatorType::Modulo:
+                return ['$mod' => [['$ifNull' => [$reference, 0]], $values[0]]];
+
+            case OperatorType::Power:
+                $base = ['$ifNull' => [$reference, 0]];
+                $exponent = $this->getNumericOperand($values, 0, 1, $method);
+                $expression = ['$pow' => [$base, $exponent]];
                 if (isset($values[1])) {
-                    // Apply the power only if the result stays within the max; otherwise leave the
-                    // value unchanged. Overflow yields Infinity, which is greater than the max, so
-                    // it correctly stays put.
-                    $expr = ['$cond' => [['$lte' => [$expr, $values[1]]], $expr, $base]];
-
-                    // Never compute $pow for an undefined input (0 to a negative power, or a
-                    // negative base to a fractional exponent): it yields NaN, which Mongo orders
-                    // below every number, so a plain `<= max` check would wrongly apply it. The
-                    // exponent is constant, so only guard the base condition it can actually trigger.
+                    $expression = ['$cond' => [['$lte' => [$expression, $values[1]]], $expression, $base]];
                     $guards = [];
                     if ($exponent < 0) {
                         $guards[] = ['$eq' => [$base, 0]];
@@ -1918,61 +1748,58 @@ private function getOperatorExpression(Operator $operator, string $field): mixed
                     if (\floor($exponent) != $exponent) {
                         $guards[] = ['$lt' => [$base, 0]];
                     }
-                    if (!empty($guards)) {
+                    if (! empty($guards)) {
                         $undefined = \count($guards) === 1 ? $guards[0] : ['$or' => $guards];
-                        $expr = ['$cond' => [$undefined, $base, $expr]];
+                        $expression = ['$cond' => [$undefined, $base, $expression]];
                     }
                 }
-                return $expr;
 
-                // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                return ['$concat' => [['$ifNull' => [$ref, '']], ['$literal' => $values[0] ?? '']]];
+                return $expression;
+
+            case OperatorType::StringConcat:
+                return ['$concat' => [['$ifNull' => [$reference, '']], ['$literal' => $values[0] ?? '']]];
 
-            case Operator::TYPE_STRING_REPLACE:
-                // An empty search is a no-op (matches SQL REPLACE semantics); MongoDB's
-                // $replaceAll would otherwise insert the replacement between every character.
+            case OperatorType::StringReplace:
                 if (($values[0] ?? '') === '') {
-                    return ['$ifNull' => [$ref, '']];
+                    return ['$ifNull' => [$reference, '']];
                 }
+
                 return ['$replaceAll' => [
-                    'input' => ['$ifNull' => [$ref, '']],
+                    'input' => ['$ifNull' => [$reference, '']],
                     'find' => ['$literal' => $values[0]],
                     'replacement' => ['$literal' => $values[1] ?? ''],
                 ]];
 
-                // Boolean operators
-            case Operator::TYPE_TOGGLE:
-                return ['$not' => [['$ifNull' => [$ref, false]]]];
+            case OperatorType::Toggle:
+                return ['$not' => [['$ifNull' => [$reference, false]]]];
 
-                // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                return ['$concatArrays' => [['$ifNull' => [$ref, []]], ['$literal' => \array_values($values)]]];
+            case OperatorType::ArrayAppend:
+                return ['$concatArrays' => [['$ifNull' => [$reference, []]], ['$literal' => \array_values($values)]]];
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                return ['$concatArrays' => [['$literal' => \array_values($values)], ['$ifNull' => [$ref, []]]]];
+            case OperatorType::ArrayPrepend:
+                return ['$concatArrays' => [['$literal' => \array_values($values)], ['$ifNull' => [$reference, []]]]];
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $index = (int)($values[0] ?? 0);
+            case OperatorType::ArrayInsert:
+                $index = $this->getIntegerOperand($values, 0, 0, $method);
                 $value = $values[1] ?? null;
-                $size = ['$size' => '$$arr'];
-                $before = ['$cond' => [['$lte' => [$index, 0]], [], ['$slice' => ['$$arr', $index]]]];
-                $after = ['$cond' => [['$gte' => [$index, $size]], [], ['$slice' => ['$$arr', ['$subtract' => [$index, $size]]]]]];
+                $size = ['$size' => '$$array'];
+                $before = ['$cond' => [['$lte' => [$index, 0]], [], ['$slice' => ['$$array', $index]]]];
+                $after = ['$cond' => [['$gte' => [$index, $size]], [], ['$slice' => ['$$array', ['$subtract' => [$index, $size]]]]]];
+
                 return ['$let' => [
-                    'vars' => ['arr' => ['$ifNull' => [$ref, []]]],
+                    'vars' => ['array' => ['$ifNull' => [$reference, []]]],
                     'in' => ['$concatArrays' => [$before, ['$literal' => [$value]], $after]],
                 ]];
 
-            case Operator::TYPE_ARRAY_REMOVE:
+            case OperatorType::ArrayRemove:
                 return ['$filter' => [
-                    'input' => ['$ifNull' => [$ref, []]],
+                    'input' => ['$ifNull' => [$reference, []]],
                     'cond' => ['$ne' => ['$$this', ['$literal' => $values[0] ?? null]]],
                 ]];
 
-            case Operator::TYPE_ARRAY_UNIQUE:
-                // Preserve first-occurrence order while removing duplicates
+            case OperatorType::ArrayUnique:
                 return ['$reduce' => [
-                    'input' => ['$ifNull' => [$ref, []]],
+                    'input' => ['$ifNull' => [$reference, []]],
                     'initialValue' => [],
                     'in' => ['$cond' => [
                         ['$in' => ['$$this', '$$value']],
@@ -1981,54 +1808,89 @@ private function getOperatorExpression(Operator $operator, string $field): mixed
                     ]],
                 ]];
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                // Keep elements present in the given set, preserving original order
+            case OperatorType::ArrayIntersect:
                 return ['$filter' => [
-                    'input' => ['$ifNull' => [$ref, []]],
+                    'input' => ['$ifNull' => [$reference, []]],
                     'cond' => ['$in' => ['$$this', ['$literal' => \array_values($values)]]],
                 ]];
 
-            case Operator::TYPE_ARRAY_DIFF:
-                // Remove elements present in the given set, preserving original order
+            case OperatorType::ArrayDiff:
                 return ['$filter' => [
-                    'input' => ['$ifNull' => [$ref, []]],
+                    'input' => ['$ifNull' => [$reference, []]],
                     'cond' => ['$not' => [['$in' => ['$$this', ['$literal' => \array_values($values)]]]]],
                 ]];
 
-            case Operator::TYPE_ARRAY_FILTER:
+            case OperatorType::ArrayFilter:
                 return ['$filter' => [
-                    'input' => ['$ifNull' => [$ref, []]],
-                    'cond' => $this->getArrayFilterCondition((string)($values[0] ?? ''), $values[1] ?? null),
+                    'input' => ['$ifNull' => [$reference, []]],
+                    'cond' => $this->getArrayFilterCondition($this->getStringOperand($values, 0, '', $method), $values[1] ?? null),
                 ]];
 
-                // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
+            case OperatorType::DateAddDays:
                 return ['$dateAdd' => [
-                    'startDate' => ['$ifNull' => [$ref, '$$NOW']],
+                    'startDate' => ['$ifNull' => [$reference, '$$NOW']],
                     'unit' => 'day',
-                    'amount' => (int)($values[0] ?? 0),
+                    'amount' => $this->getIntegerOperand($values, 0, 0, $method),
                 ]];
 
-            case Operator::TYPE_DATE_SUB_DAYS:
+            case OperatorType::DateSubDays:
                 return ['$dateSubtract' => [
-                    'startDate' => ['$ifNull' => [$ref, '$$NOW']],
+                    'startDate' => ['$ifNull' => [$reference, '$$NOW']],
                     'unit' => 'day',
-                    'amount' => (int)($values[0] ?? 0),
+                    'amount' => $this->getIntegerOperand($values, 0, 0, $method),
                 ]];
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return '$$NOW';
+        }
+    }
 
-            default:
-                throw new DatabaseException("Unsupported operator: {$method}");
+    /**
+     * @param  array<mixed>  $values
+     *
+     * @throws DatabaseException
+     */
+    private function getNumericOperand(array $values, int $offset, int|float $default, OperatorType $method): int|float
+    {
+        $value = $values[$offset] ?? $default;
+        if (! \is_int($value) && ! \is_float($value)) {
+            throw new DatabaseException('Invalid numeric operand for operator '.$method->value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * @param  array<mixed>  $values
+     *
+     * @throws DatabaseException
+     */
+    private function getIntegerOperand(array $values, int $offset, int $default, OperatorType $method): int
+    {
+        $value = $values[$offset] ?? $default;
+        if (! \is_int($value)) {
+            throw new DatabaseException('Invalid integer operand for operator '.$method->value);
         }
+
+        return $value;
     }
 
     /**
-     * Build the aggregation condition expression used by the arrayFilter operator.
+     * @param  array<mixed>  $values
      *
-     * @param string $condition
-     * @param mixed $compare
+     * @throws DatabaseException
+     */
+    private function getStringOperand(array $values, int $offset, string $default, OperatorType $method): string
+    {
+        $value = $values[$offset] ?? $default;
+        if (! \is_string($value)) {
+            throw new DatabaseException('Invalid string operand for operator '.$method->value);
+        }
+
+        return $value;
+    }
+
+    /**
      * @return array<string, mixed>
      */
     private function getArrayFilterCondition(string $condition, mixed $compare): array
@@ -2044,15 +1906,14 @@ private function getArrayFilterCondition(string $condition, mixed $compare): arr
             'lessThanEqual' => ['$lte' => ['$$this', $value]],
             'isNull' => ['$eq' => ['$$this', null]],
             'isNotNull' => ['$ne' => ['$$this', null]],
-            default => ['$literal' => true], // unknown condition keeps every element
+            default => ['$literal' => true],
         };
     }
 
     /**
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Change> $changes
+     * @param  array<Change>  $changes
      * @return array<Document>
+     *
      * @throws DatabaseException
      */
     public function upsertDocuments(Document $collection, string $attribute, array $changes): array
@@ -2061,8 +1922,11 @@ public function upsertDocuments(Document $collection, string $attribute, array $
             return $changes;
         }
 
+        $this->syncWriteHooks();
+        $this->syncReadHooks();
+
         try {
-            $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+            $name = $this->getNamespace().'_'.$this->filter($collection->getId());
             $attribute = $this->filter($attribute);
 
             $operations = [];
@@ -2070,35 +1934,30 @@ public function upsertDocuments(Document $collection, string $attribute, array $
             foreach ($changes as $change) {
                 $document = $change->getNew();
                 $oldDocument = $change->getOld();
+                /** @var array<string, mixed> $attributes */
                 $attributes = $document->getAttributes();
-                $attributes['_uid'] = $document->getId();
-                $attributes['_createdAt'] = $document['$createdAt'];
-                $attributes['_updatedAt'] = $document['$updatedAt'];
-                $attributes['_permissions'] = $document->getPermissions();
-
-                if (!empty($document->getSequence())) {
-                    $attributes['_id'] = $document->getSequence();
-                }
+                $attributes[Storage::UID] = $document->getId();
+                $attributes[Storage::CREATED_AT] = $document[Document::CREATED_AT];
+                $attributes[Storage::UPDATED_AT] = $document[Document::UPDATED_AT];
+                $attributes[Storage::PERMISSIONS] = $document->getPermissions();
 
-                if ($this->sharedTables) {
-                    $attributes['_tenant'] = $document->getTenant();
+                if (! empty($document->getSequence())) {
+                    $attributes[Storage::SEQUENCE] = $document->getSequence();
                 }
 
                 $record = $this->replaceChars('$', '_', $attributes);
+                $record = $this->decorateRow($record, $this->documentMetadata($document));
 
                 // Build filter for upsert
-                $filters = ['_uid' => $document->getId()];
+                $filters = [Storage::UID => $document->getId()];
+                $filters = $this->applyReadFilters($filters, $collection->getId());
 
-                if ($this->sharedTables) {
-                    $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-                }
-
-                unset($record['_id']); // Don't update _id
+                unset($record[Storage::SEQUENCE]); // Don't update _id
 
                 // Get fields to unset for schemaless mode
                 $unsetFields = $this->getUpsertAttributeRemovals($oldDocument, $document, $record);
 
-                if (!empty($attribute)) {
+                if (! empty($attribute)) {
                     // Get the attribute value before removing it from $set
                     $attributeValue = $record[$attribute] ?? 0;
 
@@ -2112,46 +1971,37 @@ public function upsertDocuments(Document $collection, string $attribute, array $
                     // Increment the specific attribute and update all other fields
                     $update = [
                         '$inc' => [$attribute => $attributeValue],
-                        '$set' => $record
+                        '$set' => $record,
                     ];
 
-                    if (!empty($unsetFields)) {
+                    if (! empty($unsetFields)) {
                         $update['$unset'] = $unsetFields;
                     }
                 } else {
                     $pipeline = $this->buildOperatorPipeline($record);
-
                     if ($pipeline !== null) {
-                        // Operator-based upsert: resolve operators via an aggregation pipeline
-                        // so they apply atomically, with $ifNull defaults on insert.
                         $set = $pipeline[0]['$set'];
-
-                        // Generate an _id only on insert; keep the existing one on update.
                         if (empty($document->getSequence())) {
-                            $set['_id'] = ['$ifNull' => ['$_id', $this->client->createUuid()]];
+                            $set[Storage::SEQUENCE] = ['$ifNull' => ['$' . Storage::SEQUENCE, $this->client->createUuid()]];
                         }
 
                         $update = [['$set' => $set]];
-
-                        if (!empty($unsetFields)) {
+                        if (! empty($unsetFields)) {
                             $update[] = ['$unset' => \array_keys($unsetFields)];
                         }
-
                         $hasPipeline = true;
                     } else {
-                        // Update all fields
                         $update = [
-                            '$set' => $record
+                            '$set' => $record,
                         ];
 
-                        if (!empty($unsetFields)) {
+                        if (! empty($unsetFields)) {
                             $update['$unset'] = $unsetFields;
                         }
 
-                        // Add UUID7 _id for new documents in upsert operations
                         if (empty($document->getSequence())) {
                             $update['$setOnInsert'] = [
-                                '_id' => $this->client->createUuid()
+                                Storage::SEQUENCE => $this->client->createUuid(),
                             ];
                         }
                     }
@@ -2166,8 +2016,6 @@ public function upsertDocuments(Document $collection, string $attribute, array $
             $options = $this->getTransactionOptions();
 
             if ($hasPipeline) {
-                // The client's upsert() wraps each update in toObject(), which would corrupt a
-                // pipeline (a list). Send the raw command so BSON encodes pipelines as arrays.
                 $this->executeUpsert($name, $operations, $options);
             } else {
                 $this->client->upsert(
@@ -2184,167 +2032,103 @@ public function upsertDocuments(Document $collection, string $attribute, array $
     }
 
     /**
-     * Get fields to unset for schemaless upsert operations
+     * Delete Document
      *
-     * @param Document $oldDocument
-     * @param Document $newDocument
-     * @param array<string, mixed> $record
-     * @return array<string, string>
+     *
+     * @throws Exception
      */
-    private function getUpsertAttributeRemovals(Document $oldDocument, Document $newDocument, array $record): array
+    public function deleteDocument(string $collection, string $id): bool
     {
-        $unsetFields = [];
-
-        if ($this->getSupportForAttributes() || $oldDocument->isEmpty()) {
-            return $unsetFields;
-        }
-
-        $oldUserAttributes = $oldDocument->getAttributes();
-        $newUserAttributes = $newDocument->getAttributes();
-
-        $protectedFields = ['_uid', '_id', '_createdAt', '_updatedAt', '_permissions', '_tenant'];
+        $name = $this->getNamespace().'_'.$this->filter($collection);
 
-        foreach ($oldUserAttributes as $originalKey => $originalValue) {
-            if (in_array($originalKey, $protectedFields) || array_key_exists($originalKey, $newUserAttributes)) {
-                continue;
-            }
+        $filters = [Storage::UID => $id];
 
-            $transformed = $this->replaceChars('$', '_', [$originalKey => $originalValue]);
-            $dbKey = array_key_first($transformed);
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection);
 
-            if ($dbKey && !array_key_exists($dbKey, $record) && !in_array($dbKey, $protectedFields)) {
-                $unsetFields[$dbKey] = '';
-            }
-        }
+        $options = $this->getTransactionOptions();
+        $result = $this->client->delete($name, $filters, 1, [], $options);
 
-        return $unsetFields;
+        return (bool) $result;
     }
 
     /**
-     * Get sequences for documents that were created
+     * Delete Documents
+     *
+     * @param  array<string>  $sequences
+     * @param  array<string>  $permissionIds
      *
-     * @param string $collection
-     * @param array<Document> $documents
-     * @return array<Document>
      * @throws DatabaseException
-     * @throws MongoException
      */
-    public function getSequences(string $collection, array $documents): array
+    public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
     {
-        $documentIds = [];
-        $documentTenants = [];
-        foreach ($documents as $document) {
-            if (empty($document->getSequence())) {
-                $documentIds[] = $document->getId();
-
-                if ($this->sharedTables) {
-                    $documentTenants[] = $document->getTenant();
-                }
-            }
-        }
-
-        if (empty($documentIds)) {
-            return $documents;
-        }
-
-        $sequences = [];
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-
-        $filters = ['_uid' => ['$in' => $documentIds]];
+        $name = $this->getNamespace().'_'.$this->filter($collection);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection, $documentTenants);
+        foreach ($sequences as $index => $sequence) {
+            $sequences[$index] = $sequence;
         }
-        try {
-            // Use cursor paging for large result sets
-            $options = [
-                'projection' => ['_uid' => 1, '_id' => 1],
-                'batchSize' => self::DEFAULT_BATCH_SIZE
-            ];
-
-            $options = $this->getTransactionOptions($options);
-            $response = $this->client->find($name, $filters, $options);
-            $results = $response->cursor->firstBatch ?? [];
-
-            // Process first batch
-            foreach ($results as $result) {
-                $sequences[$result->_uid] = (string)$result->_id;
-            }
 
-            // Get cursor ID for subsequent batches
-            $cursorId = $response->cursor->id ?? null;
+        /** @var array<string, mixed> $filters */
+        $filters = $this->buildFilters([new Query(Method::Equal, Storage::SEQUENCE, $sequences)]);
 
-            // Continue fetching with getMore
-            while ($cursorId && $cursorId !== 0) {
-                $moreResponse = $this->client->getMore((int)$cursorId, $name, self::DEFAULT_BATCH_SIZE);
-                $moreResults = $moreResponse->cursor->nextBatch ?? [];
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection);
 
-                if (empty($moreResults)) {
-                    break;
-                }
+        $filters = $this->replaceInternalIdsKeys($filters, '$', '_', $this->operators);
 
-                foreach ($moreResults as $result) {
-                    $sequences[$result->_uid] = (string)$result->_id;
-                }
+        $options = $this->getTransactionOptions();
 
-                // Update cursor ID for next iteration
-                $cursorId = (int)($moreResponse->cursor->id ?? 0);
-            }
+        try {
+            return $this->client->delete(
+                collection: $name,
+                filters: $filters,
+                limit: 0,
+                options: $options
+            );
         } catch (MongoException $e) {
             throw $this->processException($e);
         }
-
-        foreach ($documents as $document) {
-            if (isset($sequences[$document->getId()])) {
-                $document['$sequence'] = $sequences[$document->getId()];
-            }
-        }
-
-        return $documents;
     }
 
     /**
      * Increase or decrease an attribute value
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $attribute
-     * @param int|float $value
-     * @param string $updatedAt
-     * @param int|float|null $min
-     * @param int|float|null $max
-     * @return bool
      * @throws DatabaseException
      * @throws MongoException
      * @throws Exception
      */
-    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value, string $updatedAt, int|float|null $min = null, int|float|null $max = null): bool
+    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float|string $value, string $updatedAt, int|float|string|null $min = null, int|float|string|null $max = null): bool
     {
+        $value = $this->normalizeAtomicNumber($value, 'value');
+        $min = $min === null ? null : $this->normalizeAtomicNumber($min, 'minimum');
+        $max = $max === null ? null : $this->normalizeAtomicNumber($max, 'maximum');
+
         $attribute = $this->filter($attribute);
-        $filters = ['_uid' => $id];
+        $filters = [Storage::UID => $id];
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection);
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection);
 
         if ($max !== null || $min !== null) {
-            $filters[$attribute] = [];
+            /** @var array<string, int|float> $attributeFilter */
+            $attributeFilter = [];
             if ($max !== null) {
-                $filters[$attribute]['$lte'] = $max;
+                $attributeFilter['$lte'] = $max;
             }
             if ($min !== null) {
-                $filters[$attribute]['$gte'] = $min;
+                $attributeFilter['$gte'] = $min;
             }
+            $filters[$attribute] = $attributeFilter;
         }
 
         $options = $this->getTransactionOptions();
         try {
             $this->client->update(
-                $this->getNamespace() . '_' . $this->filter($collection),
+                $this->getNamespace().'_'.$this->filter($collection),
                 $filters,
                 [
                     '$inc' => [$attribute => $value],
-                    '$set' => ['_updatedAt' => $this->toMongoDatetime($updatedAt)],
+                    '$set' => [Storage::UPDATED_AT => $this->toMongoDatetime($updatedAt)],
                 ],
                 options: $options
             );
@@ -2355,211 +2139,98 @@ public function increaseDocumentAttribute(string $collection, string $id, string
         return true;
     }
 
+    private function normalizeAtomicNumber(int|float|string $value, string $name): int|float
+    {
+        if (! \is_string($value)) {
+            return $value;
+        }
+        if (! BigInt::fitsPhpInt($value)) {
+            throw new TypeException("MongoDB cannot safely apply {$name} outside the signed 64-bit integer range.");
+        }
+
+        return (int) $value;
+    }
+
     /**
-     * Delete Document
+     * Find Documents
      *
-     * @param string $collection
-     * @param string $id
+     * Find data sets using chosen queries
+     *
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
+     * @return array<Document>
      *
-     * @return bool
      * @throws Exception
+     * @throws TimeoutException
      */
-    public function deleteDocument(string $collection, string $id): bool
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-
-        $filters = [];
-        $filters['_uid'] = $id;
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
+        $queries = array_map(fn ($query) => clone $query, $queries);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection);
-        }
+        // Escape query attribute names that contain dots and match collection attributes
+        // (to distinguish from nested object paths like profile.level1.value)
+        $this->escapeQueryAttributes($collection, $queries);
 
-        $options = $this->getTransactionOptions();
-        $result = $this->client->delete($name, $filters, 1, [], $options);
+        /** @var array<string, mixed> $filters */
+        $filters = $this->buildFilters($queries);
 
-        return (!!$result);
-    }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId(), $forPermission->value);
 
-    /**
-     * Delete Documents
-     *
-     * @param string $collection
-     * @param array<string> $sequences
-     * @param array<string> $permissionIds
-     * @return int
-     * @throws DatabaseException
-     */
-    public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
+        $options = [];
 
-        foreach ($sequences as $index => $sequence) {
-            $sequences[$index] = $sequence;
+        if (! \is_null($limit)) {
+            $options['limit'] = $limit;
+        }
+        if (! \is_null($offset)) {
+            $options['skip'] = $offset;
         }
 
-        $filters = $this->buildFilters([new Query(Query::TYPE_EQUAL, '_id', $sequences)]);
+        if ($this->timeout) {
+            $options['maxTimeMS'] = $this->timeout;
+        }
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection);
+        $selections = $this->getAttributeSelections($queries);
+        $hasProjection = ! empty($selections) && ! \in_array('*', $selections);
+        if ($hasProjection) {
+            $options['projection'] = $this->getAttributeProjection($selections);
         }
 
-        $filters = $this->replaceInternalIdsKeys($filters, '$', '_', $this->operators);
+        // Add transaction context to options
+        $options = $this->getTransactionOptions($options);
 
-        $options = $this->getTransactionOptions();
-
-        try {
-            return $this->client->delete(
-                collection: $name,
-                filters: $filters,
-                limit: 0,
-                options: $options
-            );
-        } catch (MongoException $e) {
-            throw $this->processException($e);
-        }
-    }
-
-    /**
-     * Update Attribute.
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param string $newKey
-     *
-     * @return bool
-     */
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
-    {
-        if (!empty($newKey) && $newKey !== $id) {
-            return $this->renameAttribute($collection, $id, $newKey);
-        }
-        return true;
-    }
-
-    /**
-     * TODO Consider moving this to adapter.php
-     * @param string $attribute
-     * @return string
-     */
-    protected function getInternalKeyForAttribute(string $attribute): string
-    {
-        return match ($attribute) {
-            '$id' => '_uid',
-            '$sequence' => '_id',
-            '$collection' => '_collection',
-            '$tenant' => '_tenant',
-            '$createdAt' => '_createdAt',
-            '$updatedAt' => '_updatedAt',
-            '$deletedAt' => '_deletedAt',
-            '$permissions' => '_permissions',
-            default => $attribute
-        };
-    }
-
-    /**
-     * @return list<string>
-     */
-    private function permissionStrings(string $type): array
-    {
-        $permissions = [];
-        foreach ($this->authorization->getRoles() as $role) {
-            $permissions[] = $type . '("' . $role . '")';
-        }
-
-        return $permissions;
-    }
-
-    /**
-     * Find Documents
-     *
-     * Find data sets using chosen queries
-     *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $limit
-     * @param int|null $offset
-     * @param array<string> $orderAttributes
-     * @param array<string> $orderTypes
-     * @param array<string, mixed> $cursor
-     * @param string $cursorDirection
-     * @param string $forPermission
-     *
-     * @return array<Document>
-     * @throws Exception
-     * @throws TimeoutException
-     */
-    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
-        $queries = array_map(fn ($query) => clone $query, $queries);
-
-        // Escape query attribute names that contain dots and match collection attributes
-        // (to distinguish from nested object paths like profile.level1.value)
-        $this->escapeQueryAttributes($collection, $queries);
-
-        $filters = $this->buildFilters($queries);
-
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
-
-        // permissions
-        if ($this->authorization->getStatus()) {
-            $filters['_permissions']['$in'] = $this->permissionStrings($forPermission);
-        }
-
-        $options = [];
-
-        if (!\is_null($limit)) {
-            $options['limit'] = $limit;
-        }
-        if (!\is_null($offset)) {
-            $options['skip'] = $offset;
-        }
-
-        if ($this->timeout) {
-            $options['maxTimeMS'] = $this->timeout;
-        }
-
-        $selections = $this->getAttributeSelections($queries);
-        $hasProjection = !empty($selections) && !\in_array('*', $selections);
-        if ($hasProjection) {
-            $options['projection'] = $this->getAttributeProjection($selections);
-        }
-
-        // Add transaction context to options
-        $options = $this->getTransactionOptions($options);
-
-        $orFilters = [];
+        $orFilters = [];
+        /** @var array<string, int> $sortOptions */
+        $sortOptions = [];
 
         foreach ($orderAttributes as $i => $originalAttribute) {
             $attribute = $this->getInternalKeyForAttribute($originalAttribute);
             $attribute = $this->filter($attribute);
 
-            $orderType = $this->filter($orderTypes[$i] ?? Database::ORDER_ASC);
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
             $direction = $orderType;
 
             /** Get sort direction  ASC || DESC **/
-            if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $direction = ($direction === Database::ORDER_ASC)
-                    ? Database::ORDER_DESC
-                    : Database::ORDER_ASC;
+            if ($cursorDirection === CursorDirection::Before) {
+                $direction = ($direction === OrderDirection::Asc)
+                    ? OrderDirection::Desc
+                    : OrderDirection::Asc;
             }
 
-            $options['sort'][$attribute] = $this->getOrder($direction);
+            $sortOptions[$attribute] = $this->getOrder($direction);
+            $options['sort'] = $sortOptions;
 
             /** Get operator sign  '$lt' ? '$gt' **/
-            $operator = $cursorDirection === Database::CURSOR_AFTER
-                ? ($orderType === Database::ORDER_DESC ? Query::TYPE_LESSER : Query::TYPE_GREATER)
-                : ($orderType === Database::ORDER_DESC ? Query::TYPE_GREATER : Query::TYPE_LESSER);
+            $operator = $cursorDirection === CursorDirection::After
+                ? ($orderType === OrderDirection::Desc ? Method::LessThan : Method::GreaterThan)
+                : ($orderType === OrderDirection::Desc ? Method::GreaterThan : Method::LessThan);
 
             $operator = $this->getQueryOperator($operator);
 
-            if (!empty($cursor)) {
+            if (! empty($cursor)) {
 
                 $andConditions = [];
                 for ($j = 0; $j < $i; $j++) {
@@ -2567,17 +2238,17 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                     $prevAttr = $this->filter($this->getInternalKeyForAttribute($originalPrev));
                     $tmp = $cursor[$originalPrev];
                     $andConditions[] = [
-                        $prevAttr => $tmp
+                        $prevAttr => $tmp,
                     ];
                 }
 
                 $tmp = $cursor[$originalAttribute];
 
-                if ($originalAttribute === '$sequence') {
+                if ($originalAttribute === Document::SEQUENCE) {
                     /** If there is only $sequence attribute in $orderAttributes skip Or And  operators **/
                     if (count($orderAttributes) === 1) {
                         $filters[$attribute] = [
-                            $operator => $tmp
+                            $operator => $tmp,
                         ];
                         break;
                     }
@@ -2585,24 +2256,26 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
 
                 $andConditions[] = [
                     $attribute => [
-                        $operator => $tmp
-                    ]
+                        $operator => $tmp,
+                    ],
                 ];
 
                 $orFilters[] = [
-                    '$and' => $andConditions
+                    '$and' => $andConditions,
                 ];
             }
         }
 
-        if (!empty($orFilters)) {
+        if (! empty($orFilters)) {
             $filters['$or'] = $orFilters;
         }
 
         // Translate operators and handle time filters
+        /** @var array<string, mixed> $filters */
         $filters = $this->replaceInternalIdsKeys($filters, '$', '_', $this->operators);
 
         $found = [];
+        /** @var int|null $cursorId */
         $cursorId = null;
 
         try {
@@ -2610,31 +2283,63 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             $options['batchSize'] = self::DEFAULT_BATCH_SIZE;
 
             $response = $this->client->find($name, $filters, $options);
-            $results = $response->cursor->firstBatch ?? [];
+            /** @var \stdClass $responseCursorFind */
+            $responseCursorFind = $response->cursor;
+            /** @var array<mixed> $results */
+            $results = $responseCursorFind->firstBatch ?? [];
             // Process first batch
             foreach ($results as $result) {
-                $record = $this->replaceChars('_', '$', (array)$result);
-                $found[] = new Document($this->convertStdClassToArray($record));
+                /** @var array<string, mixed> $resultCast */
+                $resultCast = (array) $result;
+                $record = $this->replaceChars('_', '$', $resultCast);
+                /** @var array<string, mixed> $convertedRecord */
+                $convertedRecord = $this->convertStdClassToArray($record);
+                $found[] = new Document($convertedRecord);
             }
 
             // Get cursor ID for subsequent batches
-            $cursorId = $response->cursor->id ?? null;
+            if (isset($responseCursorFind->id)) {
+                /** @var mixed $responseCursorFindId */
+                $responseCursorFindId = $responseCursorFind->id;
+                $cursorId = \is_int($responseCursorFindId) ? $responseCursorFindId : (\is_scalar($responseCursorFindId) ? (int) $responseCursorFindId : null);
+                if ($cursorId === 0) {
+                    $cursorId = null;
+                }
+            } else {
+                $cursorId = null;
+            }
 
             // Continue fetching with getMore
-            while ($cursorId && $cursorId !== 0) {
-                $moreResponse = $this->client->getMore((int)$cursorId, $name, self::DEFAULT_BATCH_SIZE);
-                $moreResults = $moreResponse->cursor->nextBatch ?? [];
+            while ($cursorId !== null) {
+                $moreResponse = $this->client->getMore($cursorId, $name, self::DEFAULT_BATCH_SIZE);
+                /** @var \stdClass $moreCursorFind */
+                $moreCursorFind = $moreResponse->cursor;
+                /** @var array<mixed> $moreResults */
+                $moreResults = $moreCursorFind->nextBatch ?? [];
 
                 if (empty($moreResults)) {
                     break;
                 }
 
                 foreach ($moreResults as $result) {
-                    $record = $this->replaceChars('_', '$', (array)$result);
-                    $found[] = new Document($this->convertStdClassToArray($record));
+                    /** @var array<string, mixed> $resultCast */
+                    $resultCast = (array) $result;
+                    $record = $this->replaceChars('_', '$', $resultCast);
+                    /** @var array<string, mixed> $convertedRecord */
+                    $convertedRecord = $this->convertStdClassToArray($record);
+                    $found[] = new Document($convertedRecord);
                 }
 
-                $cursorId = (int)($moreResponse->cursor->id ?? 0);
+                if (isset($moreCursorFind->id)) {
+                    /** @var mixed $moreCursorFindId */
+                    $moreCursorFindId = $moreCursorFind->id;
+                    $cursorId = \is_int($moreCursorFindId) ? $moreCursorFindId : (\is_scalar($moreCursorFindId) ? (int) $moreCursorFindId : null);
+                    if ($cursorId === 0) {
+                        $cursorId = null;
+                    }
+                } else {
+                    $cursorId = null;
+                }
             }
         } catch (MongoException $e) {
             throw $this->processException($e);
@@ -2644,20 +2349,20 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                 try {
                     $this->client->query([
                         'killCursors' => $name,
-                        'cursors' => [(int)$cursorId]
+                        'cursors' => [$cursorId],
                     ]);
-                } catch (\Exception $e) {
+                } catch (Exception $e) {
                     // Ignore errors during cursor cleanup
                 }
             }
         }
 
-        if ($cursorDirection === Database::CURSOR_BEFORE) {
+        if ($cursorDirection === CursorDirection::Before) {
             $found = array_reverse($found);
         }
 
         // Ensure missing relationship attributes are set to null (MongoDB doesn't store null fields)
-        if (!$hasProjection) {
+        if (! $hasProjection) {
             foreach ($found as $document) {
                 $this->ensureRelationshipDefaults($collection, $document);
             }
@@ -2666,84 +2371,16 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
         return $found;
     }
 
-
-    /**
-     * Converts Appwrite database type to MongoDB BSON type code.
-     *
-     * @param string $appwriteType
-     * @return string
-     */
-    private function getMongoTypeCode(string $appwriteType): string
-    {
-        return match ($appwriteType) {
-            Database::VAR_STRING => 'string',
-            Database::VAR_VARCHAR => 'string',
-            Database::VAR_TEXT => 'string',
-            Database::VAR_MEDIUMTEXT => 'string',
-            Database::VAR_LONGTEXT => 'string',
-            Database::VAR_INTEGER => 'int',
-            Database::VAR_BIGINT => 'long',
-            Database::VAR_FLOAT => 'double',
-            Database::VAR_BOOLEAN => 'bool',
-            Database::VAR_DATETIME => 'date',
-            Database::VAR_ID => 'string',
-            Database::VAR_UUID7 => 'string',
-            default => 'string'
-        };
-    }
-
-    /**
-     * Converts timestamp to Mongo\BSON datetime format.
-     *
-     * @param string $dt
-     * @return UTCDateTime
-     * @throws Exception
-     */
-    private function toMongoDatetime(string $dt): UTCDateTime
-    {
-        return new UTCDateTime(new \DateTime($dt));
-    }
-
-    /**
-     * Recursive function to replace chars in array keys, while
-     * skipping any that are explicitly excluded.
-     *
-     * @param array<string, mixed> $array
-     * @param string $from
-     * @param string $to
-     * @param array<string> $exclude
-     * @return array<string, mixed>
-     */
-    private function replaceInternalIdsKeys(array $array, string $from, string $to, array $exclude = []): array
-    {
-        $result = [];
-
-        foreach ($array as $key => $value) {
-            if (!in_array($key, $exclude)) {
-                $key = str_replace($from, $to, $key);
-            }
-
-            $result[$key] = is_array($value)
-                ? $this->replaceInternalIdsKeys($value, $from, $to, $exclude)
-                : $value;
-        }
-
-        return $result;
-    }
-
-
     /**
      * Count Documents
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $max
-     * @return int
+     * @param  array<Query>  $queries
+     *
      * @throws Exception
      */
     public function count(Document $collection, array $queries = [], ?int $max = null): int
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         $queries = array_map(fn ($query) => clone $query, $queries);
 
@@ -2751,19 +2388,23 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
         $this->escapeQueryAttributes($collection, $queries);
 
         $filters = [];
+        $options = [];
 
-        // Build filters from queries
-        $filters = $this->buildFilters($queries);
-
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
+        if (! \is_null($max) && $max > 0) {
+            $options['limit'] = $max;
         }
 
-        // Add permissions filter if authorization is enabled
-        if ($this->authorization->getStatus()) {
-            $filters['_permissions']['$in'] = $this->permissionStrings(Database::PERMISSION_READ);
+        if ($this->timeout) {
+            $options['maxTimeMS'] = $this->timeout;
         }
 
+        // Build filters from queries
+        /** @var array<string, mixed> $filters */
+        $filters = $this->buildFilters($queries);
+
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
+
         /**
          * Use MongoDB aggregation pipeline for accurate counting
          * Accuracy and Sharded Clusters
@@ -2772,7 +2413,6 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
          * To avoid these situations, on a sharded cluster, use the db.collection.aggregate() method"
          * https://www.mongodb.com/docs/manual/reference/command/count/#response
          **/
-
         $options = $this->getTransactionOptions();
 
         if ($this->timeout) {
@@ -2782,29 +2422,29 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
         $pipeline = [];
 
         // Add match stage if filters are provided
-        if (!empty($filters)) {
+        if (! empty($filters)) {
             $pipeline[] = ['$match' => $this->client->toObject($filters)];
         }
 
         // Add limit stage if specified
-        if (!\is_null($max) && $max > 0) {
+        if (! \is_null($max) && $max > 0) {
             $pipeline[] = ['$limit' => $max];
         }
 
         // Use $group and $sum when limit is specified, $count when no limit
         // Note: $count stage doesn't works well with $limit in the same pipeline
         // When limit is specified, we need to use $group + $sum to count the limited documents
-        if (!\is_null($max) && $max > 0) {
+        if (! \is_null($max) && $max > 0) {
             // When limit is specified, use $group and $sum to count limited documents
             $pipeline[] = [
                 '$group' => [
-                    '_id' => null,
-                    'total' => ['$sum' => 1]]
+                    Storage::SEQUENCE => null,
+                    'total' => ['$sum' => 1]],
             ];
         } else {
             // When no limit is passed, use $count for better performance
             $pipeline[] = [
-                '$count' => 'total'
+                '$count' => 'total',
             ];
         }
 
@@ -2813,12 +2453,21 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
             $result = $this->client->aggregate($name, $pipeline, $options);
 
             // Aggregation returns stdClass with cursor property containing firstBatch
-            if (isset($result->cursor) && !empty($result->cursor->firstBatch)) {
-                $firstResult = $result->cursor->firstBatch[0];
-
-                // Handle both $count and $group response formats
-                if (isset($firstResult->total)) {
-                    return (int)$firstResult->total;
+            if (isset($result->cursor)) {
+                /** @var \stdClass $aggCursor */
+                $aggCursor = $result->cursor;
+                if (! empty($aggCursor->firstBatch)) {
+                    /** @var array<mixed> $aggFirstBatch */
+                    $aggFirstBatch = $aggCursor->firstBatch;
+                    /** @var \stdClass $firstResult */
+                    $firstResult = $aggFirstBatch[0];
+
+                    // Handle both $count and $group response formats
+                    if (isset($firstResult->total)) {
+                        /** @var mixed $totalVal */
+                        $totalVal = $firstResult->total;
+                        return \is_int($totalVal) ? $totalVal : (\is_numeric($totalVal) ? (int) $totalVal : 0);
+                    }
                 }
             }
 
@@ -2833,35 +2482,24 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
         }
     }
 
-
     /**
      * Sum an attribute
      *
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @param int|null $max
+     * @param  array<Query>  $queries
      *
-     * @return int|float
      * @throws Exception
      */
-
     public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection->getId());
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         // queries
         $queries = array_map(fn ($query) => clone $query, $queries);
+        /** @var array<string, mixed> $filters */
         $filters = $this->buildFilters($queries);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
-
-        // permissions
-        if ($this->authorization->getStatus()) { // skip if authorization is disabled
-            $filters['_permissions']['$in'] = $this->permissionStrings(Database::PERMISSION_READ);
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
 
         // using aggregation to get sum an attribute as described in
         // https://docs.mongodb.com/manual/reference/method/db.collection.aggregate/
@@ -2872,16 +2510,16 @@ public function sum(Document $collection, string $attribute, array $queries = []
         // We pass the $pipeline to the aggregate method, which returns a cursor, then we get
         // the array of results from the cursor, and we return the total sum of the attribute
         $pipeline = [];
-        if (!empty($filters)) {
+        if (! empty($filters)) {
             $pipeline[] = ['$match' => $filters];
         }
-        if (!empty($max)) {
+        if (! empty($max)) {
             $pipeline[] = ['$limit' => $max];
         }
         $pipeline[] = [
             '$group' => [
-                '_id' => null,
-                'total' => ['$sum' => '$' . $attribute],
+                Storage::SEQUENCE => null,
+                'total' => ['$sum' => '$'.$attribute],
             ],
         ];
 
@@ -2892,1091 +2530,1219 @@ public function sum(Document $collection, string $attribute, array $queries = []
         }
 
         try {
-            return $this->client->aggregate($name, $pipeline, $options)->cursor->firstBatch[0]->total ?? 0;
+            $sumResult = $this->client->aggregate($name, $pipeline, $options);
+            /** @var \stdClass $sumCursor */
+            $sumCursor = $sumResult->cursor;
+            /** @var array<mixed> $sumFirstBatch */
+            $sumFirstBatch = $sumCursor->firstBatch;
+            if (empty($sumFirstBatch)) {
+                return 0;
+            }
+            /** @var \stdClass $sumFirstResult */
+            $sumFirstResult = $sumFirstBatch[0];
+            if (! isset($sumFirstResult->total)) {
+                return 0;
+            }
+            /** @var mixed $sumTotal */
+            $sumTotal = $sumFirstResult->total;
+            if (\is_int($sumTotal) || \is_float($sumTotal)) {
+                return $sumTotal;
+            }
+
+            return \is_numeric($sumTotal) ? (int) $sumTotal : 0;
         } catch (MongoException $e) {
             throw $this->processException($e);
         }
     }
 
     /**
-     * @return Client
+     * Get sequences for documents that were created
      *
-     * @throws Exception
-     */
-    protected function getClient(): Client
-    {
-        return $this->client;
-    }
-
-    /**
-     * Escape a field name for MongoDB storage.
-     * MongoDB field names cannot start with $ or contain dots.
+     * @param  array<Document>  $documents
+     * @return array<Document>
      *
-     * @param string $name
-     * @return string
+     * @throws DatabaseException
+     * @throws MongoException
      */
-    protected function escapeMongoFieldName(string $name): string
+    public function getSequences(string $collection, array $documents): array
     {
-        if (\str_starts_with($name, '$')) {
-            $name = '_' . \substr($name, 1);
-        }
-        if (\str_contains($name, '.')) {
-            $name = \str_replace('.', '__dot__', $name);
-        }
-        return $name;
-    }
+        $documentIds = [];
+        /** @var array<int> $documentTenants */
+        $documentTenants = [];
+        foreach ($documents as $document) {
+            if (empty($document->getSequence())) {
+                $documentIds[] = $document->getId();
 
-    /**
-     * Escape query attribute names that contain dots and match known collection attributes.
-     * This distinguishes field names with dots (like 'collectionSecurity.Parent') from
-     * nested object paths (like 'profile.level1.value').
-     *
-     * @param Document $collection
-     * @param array<Query> $queries
-     */
-    protected function escapeQueryAttributes(Document $collection, array $queries): void
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-        $dotAttributes = [];
-        foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            if (\str_contains($key, '.') || \str_starts_with($key, '$')) {
-                $dotAttributes[$key] = $this->escapeMongoFieldName($key);
+                if ($this->sharedTables) {
+                    $tenant = $document->getTenant();
+                    if ($tenant !== null) {
+                        $documentTenants[] = $tenant;
+                    }
+                }
             }
         }
 
-        if (empty($dotAttributes)) {
-            return;
+        if (empty($documentIds)) {
+            return $documents;
         }
 
-        foreach ($queries as $query) {
-            $attr = $query->getAttribute();
-            if (isset($dotAttributes[$attr])) {
-                $query->setAttribute($dotAttributes[$attr]);
-            }
+        $sequences = [];
+        $name = $this->getNamespace().'_'.$this->filter($collection);
+
+        $filters = [Storage::UID => ['$in' => $documentIds]];
+
+        if ($this->sharedTables) {
+            $filters[Storage::TENANT] = $this->getTenantFilters($collection, $documentTenants);
         }
-    }
+        try {
+            // Use cursor paging for large result sets
+            $options = [
+                'projection' => [Storage::UID => 1, Storage::SEQUENCE => 1],
+                'batchSize' => self::DEFAULT_BATCH_SIZE,
+            ];
 
-    /**
-     * Ensure relationship attributes have default null values in MongoDB documents.
-     * MongoDB doesn't store null fields, so we need to add them for schema compatibility.
-     *
-     * @param Document $collection
-     * @param Document $document
-     */
-    protected function ensureRelationshipDefaults(Document $collection, Document $document): void
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            $type = $attribute['type'] ?? '';
-            if ($type === Database::VAR_RELATIONSHIP && !$document->offsetExists($key)) {
-                $options = $attribute['options'] ?? [];
-                $twoWay = $options['twoWay'] ?? false;
-                $side = $options['side'] ?? '';
-                $relationType = $options['relationType'] ?? '';
+            $options = $this->getTransactionOptions($options);
+            $response = $this->client->find($name, $filters, $options);
+            /** @var \stdClass $responseCursor */
+            $responseCursor = $response->cursor;
+            /** @var array<\stdClass> $results */
+            $results = $responseCursor->firstBatch ?? [];
 
-                // Determine if this relationship stores data on this collection's documents
-                // Only set null defaults for relationships that would have a column in SQL
-                $storesData = match ($relationType) {
-                    Database::RELATION_ONE_TO_ONE => $side === Database::RELATION_SIDE_PARENT || $twoWay,
-                    Database::RELATION_ONE_TO_MANY => $side === Database::RELATION_SIDE_CHILD,
-                    Database::RELATION_MANY_TO_ONE => $side === Database::RELATION_SIDE_PARENT,
-                    Database::RELATION_MANY_TO_MANY => false,
-                    default => false,
-                };
+            // Process first batch
+            foreach ($results as $result) {
+                /** @var \stdClass $result */
+                /** @var mixed $uid */
+                $uid = $result->{Storage::UID};
+                /** @var mixed $oid */
+                $oid = $result->{Storage::SEQUENCE};
+                $uidStr = \is_string($uid) ? $uid : (\is_scalar($uid) ? (string) $uid : '');
+                $oidStr = \is_string($oid) ? $oid : (\is_scalar($oid) ? (string) $oid : '');
+                $sequences[$uidStr] = $oidStr;
+            }
 
-                if ($storesData) {
-                    $document->setAttribute($key, null);
+            // Get cursor ID for subsequent batches
+            /** @var int|null $cursorId */
+            $cursorId = null;
+            if (isset($responseCursor->id)) {
+                /** @var mixed $rcId */
+                $rcId = $responseCursor->id;
+                $cursorId = \is_int($rcId) ? $rcId : (\is_scalar($rcId) ? (int) $rcId : null);
+                if ($cursorId === 0) {
+                    $cursorId = null;
                 }
             }
-        }
-    }
 
-    /**
-     * Keys cannot begin with $ in MongoDB
-     * Convert $ prefix to _ on $id, $permissions, and $collection
-     *
-     * @param string $from
-     * @param string $to
-     * @param array<string, mixed> $array
-     * @return array<string, mixed>
-     */
-    protected function replaceChars(string $from, string $to, array $array): array
-    {
-        $filter = [
-            'permissions',
-            'createdAt',
-            'updatedAt',
-            'collection'
-        ];
+            // Continue fetching with getMore
+            while ($cursorId !== null) {
+                $moreResponse = $this->client->getMore($cursorId, $name, self::DEFAULT_BATCH_SIZE);
+                /** @var \stdClass $moreCursor */
+                $moreCursor = $moreResponse->cursor;
+                /** @var array<\stdClass> $moreResults */
+                $moreResults = $moreCursor->nextBatch ?? [];
 
-        // First pass: recursively process array values and collect keys to rename
-        $keysToRename = [];
-        foreach ($array as $k => $v) {
-            if (is_array($v)) {
-                $array[$k] = $this->replaceChars($from, $to, $v);
-            }
+                if (empty($moreResults)) {
+                    break;
+                }
 
-            $newKey = $k;
+                foreach ($moreResults as $result) {
+                    /** @var \stdClass $result */
+                    /** @var mixed $uid */
+                    $uid = $result->{Storage::UID};
+                    /** @var mixed $oid */
+                    $oid = $result->{Storage::SEQUENCE};
+                    $uidStr = \is_string($uid) ? $uid : (\is_scalar($uid) ? (string) $uid : '');
+                    $oidStr = \is_string($oid) ? $oid : (\is_scalar($oid) ? (string) $oid : '');
+                    $sequences[$uidStr] = $oidStr;
+                }
 
-            // Handle key replacement for filtered attributes
-            $clean_key = str_replace($from, "", $k);
-            if (in_array($clean_key, $filter)) {
-                $newKey = str_replace($from, $to, $k);
-            } elseif (\is_string($k) && \str_starts_with($k, $from) && !in_array($k, ['$id', '$sequence', '$tenant', '_uid', '_id', '_tenant'])) {
-                // Handle any other key starting with the 'from' char (e.g. user-defined $-prefixed keys)
-                $newKey = $to . \substr($k, \strlen($from));
-            }
-
-            // Handle dot escaping in MongoDB field names
-            if ($from === '$' && \is_string($k) && \str_contains($newKey, '.')) {
-                $newKey = \str_replace('.', '__dot__', $newKey);
-            } elseif ($from === '_' && \is_string($k) && \str_contains($k, '__dot__')) {
-                $newKey = \str_replace('__dot__', '.', $newKey);
-            }
-
-            if ($newKey !== $k) {
-                $keysToRename[$k] = $newKey;
+                // Update cursor ID for next iteration
+                if (isset($moreCursor->id)) {
+                    /** @var mixed $moreCursorIdVal */
+                    $moreCursorIdVal = $moreCursor->id;
+                    $cursorId = \is_int($moreCursorIdVal) ? $moreCursorIdVal : (\is_scalar($moreCursorIdVal) ? (int) $moreCursorIdVal : null);
+                    if ($cursorId === 0) {
+                        $cursorId = null;
+                    }
+                } else {
+                    $cursorId = null;
+                }
             }
+        } catch (MongoException $e) {
+            throw $this->processException($e);
         }
 
-        foreach ($keysToRename as $oldKey => $newKey) {
-            $array[$newKey] = $array[$oldKey];
-            unset($array[$oldKey]);
-        }
-
-        // Handle special attribute mappings
-        if ($from === '_') {
-            if (isset($array['_id'])) {
-                $array['$sequence'] = (string)$array['_id'];
-                unset($array['_id']);
-            }
-            if (isset($array['_uid'])) {
-                $array['$id'] = $array['_uid'];
-                unset($array['_uid']);
-            }
-            if (isset($array['_tenant'])) {
-                $array['$tenant'] = $array['_tenant'];
-                unset($array['_tenant']);
-            }
-        } elseif ($from === '$') {
-            if (isset($array['$id'])) {
-                $array['_uid'] = $array['$id'];
-                unset($array['$id']);
-            }
-            if (isset($array['$sequence'])) {
-                $array['_id'] = $array['$sequence'];
-                unset($array['$sequence']);
-            }
-            if (isset($array['$tenant'])) {
-                $array['_tenant'] = $array['$tenant'];
-                unset($array['$tenant']);
+        foreach ($documents as $document) {
+            if (isset($sequences[$document->getId()])) {
+                $document[Document::SEQUENCE] = $sequences[$document->getId()];
             }
         }
 
-        return $array;
+        return $documents;
     }
 
     /**
-     * @param array<Query> $queries
-     * @param string $separator
-     * @return array<mixed>
-     * @throws Exception
+     * Get max STRING limit
      */
-    protected function buildFilters(array $queries, string $separator = '$and'): array
+    public function getLimitForString(): int
     {
-        $filters = [];
-        $queries = Query::groupByType($queries)['filters'];
-
-        foreach ($queries as $query) {
-            /* @var $query Query */
-            if ($query->isNested()) {
-                if ($query->getMethod() === Query::TYPE_ELEM_MATCH) {
-                    $filters[$separator][] = [
-                        $query->getAttribute() => [
-                            '$elemMatch' => $this->buildFilters($query->getValues(), $separator)
-                        ]
-                    ];
-                    continue;
-                }
-
-                $operator = $this->getQueryOperator($query->getMethod());
-
-                $filters[$separator][] = $this->buildFilters($query->getValues(), $operator);
-            } else {
-                $filters[$separator][] = $this->buildFilter($query);
-            }
-        }
-
-        return $filters;
+        return 2147483647;
     }
 
     /**
-     * @param Query $query
-     * @return array<mixed>
-     * @throws Exception
+     * Get max INT limit
      */
-    protected function buildFilter(Query $query): array
+    public function getLimitForInt(): int
     {
-        // Normalize extended ISO 8601 datetime strings in query values to UTCDateTime
-        // so they can be correctly compared against datetime fields stored in MongoDB.
-        if (!$this->getSupportForAttributes() || \in_array($query->getAttribute(), ['$createdAt', '$updatedAt'], true)) {
-            $values = $query->getValues();
-            foreach ($values as $k => $value) {
-                if (is_string($value) && $this->isExtendedISODatetime($value)) {
-                    try {
-                        $values[$k] = $this->toMongoDatetime($value);
-                    } catch (\Throwable $th) {
-                        // Leave value as-is if it cannot be parsed as a datetime
-                    }
-                }
-            }
-            $query->setValues($values);
-        }
-
-        if ($query->getAttribute() === '$id') {
-            $query->setAttribute('_uid');
-        } elseif ($query->getAttribute() === '$sequence') {
-            $query->setAttribute('_id');
-            $values = $query->getValues();
-            foreach ($values as $k => $v) {
-                $values[$k] = $v;
-            }
-            $query->setValues($values);
-        } elseif ($query->getAttribute() === '$createdAt') {
-            $query->setAttribute('_createdAt');
-        } elseif ($query->getAttribute() === '$updatedAt') {
-            $query->setAttribute('_updatedAt');
-        } elseif (\str_starts_with($query->getAttribute(), '$')) {
-            // Escape $ prefix and dots in user-defined $-prefixed attribute names for MongoDB
-            $query->setAttribute($this->escapeMongoFieldName($query->getAttribute()));
-        }
-
-        $attribute = $query->getAttribute();
-        $operator = $this->getQueryOperator($query->getMethod());
-
-        $value = match ($query->getMethod()) {
-            Query::TYPE_IS_NULL,
-            Query::TYPE_IS_NOT_NULL => null,
-            Query::TYPE_EXISTS => true,
-            Query::TYPE_NOT_EXISTS => false,
-            default => $this->getQueryValue(
-                $query->getMethod(),
-                count($query->getValues()) > 1
-                    ? $query->getValues()
-                    : $query->getValues()[0]
-            ),
-        };
-
-        $filter = [];
-        if ($query->isObjectAttribute() && !\str_contains($attribute, '.') && in_array($query->getMethod(), [Query::TYPE_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_CONTAINS_ALL, Query::TYPE_NOT_CONTAINS, Query::TYPE_NOT_EQUAL])) {
-            $this->handleObjectFilters($query, $filter);
-            return $filter;
-        }
-
-        if ($operator == '$eq' && \is_array($value)) {
-            $filter[$attribute]['$in'] = $value;
-        } elseif ($operator == '$ne' && \is_array($value)) {
-            $filter[$attribute]['$nin'] = $value;
-        } elseif ($operator == '$all') {
-            $filter[$attribute]['$all'] = $query->getValues();
-        } elseif ($operator == '$in') {
-            if (in_array($query->getMethod(), [Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY]) && !$query->onArray()) {
-                // contains support array values
-                if (is_array($value)) {
-                    $filter['$or'] = array_map(function ($val) use ($attribute) {
-                        return [
-                            $attribute => [
-                                '$regex' => $this->createSafeRegex($val, '.*%s.*', 'i')
-                            ]
-                        ];
-                    }, $value);
-                } else {
-                    $filter[$attribute]['$regex'] = $this->createSafeRegex($value, '.*%s.*');
-                }
-            } else {
-                $filter[$attribute]['$in'] = $query->getValues();
-            }
-        } elseif ($operator === 'notContains') {
-            if (!$query->onArray()) {
-                $filter[$attribute] = ['$not' => $this->createSafeRegex($value, '.*%s.*')];
-            } else {
-                $filter[$attribute]['$nin'] = $query->getValues();
-            }
-        } elseif ($operator == '$search') {
-            if ($query->getMethod() === Query::TYPE_NOT_SEARCH) {
-                // MongoDB doesn't support negating $text expressions directly
-                // Use regex as fallback for NOT search while keeping fulltext for positive search
-                if (empty($value)) {
-                    // If value is not passed, don't add any filter - this will match all documents
-                } else {
-                    $filter[$attribute] = ['$not' => $this->createSafeRegex($value, '.*%s.*')];
-                }
-            } else {
-                $filter['$text'][$operator] = $value;
-            }
-        } elseif ($operator === Query::TYPE_BETWEEN) {
-            $filter[$attribute]['$lte'] = $value[1];
-            $filter[$attribute]['$gte'] = $value[0];
-        } elseif ($operator === Query::TYPE_NOT_BETWEEN) {
-            $filter['$or'] = [
-                [$attribute => ['$lt' => $value[0]]],
-                [$attribute => ['$gt' => $value[1]]]
-            ];
-        } elseif ($operator === '$regex' && $query->getMethod() === Query::TYPE_NOT_STARTS_WITH) {
-            $filter[$attribute] = ['$not' => $this->createSafeRegex($value, '^%s')];
-        } elseif ($operator === '$regex' && $query->getMethod() === Query::TYPE_NOT_ENDS_WITH) {
-            $filter[$attribute] = ['$not' => $this->createSafeRegex($value, '%s$')];
-        } elseif ($operator === '$exists') {
-            foreach ($query->getValues() as $attribute) {
-                $filter['$or'][] = [$attribute => [$operator => $value]];
-            }
-        } else {
-            $filter[$attribute][$operator] = $value;
-        }
-
-        return $filter;
+        // Mongo does not handle integers directly, so using MariaDB limit for now
+        return 4294967295;
     }
 
     /**
-     * @param Query $query
-     * @param array<string, mixed> $filter
-     * @return void
+     * Get max BIGINT limit
+     *
+     * @return int
      */
-    private function handleObjectFilters(Query $query, array &$filter): void
+    public function getLimitForBigInt(): int
     {
-        $conditions = [];
-        $isNot = in_array($query->getMethod(), [Query::TYPE_NOT_CONTAINS,Query::TYPE_NOT_EQUAL]);
-        $values = $query->getValues();
-        foreach ($values as $attribute => $value) {
-            $flattendQuery = $this->flattenWithDotNotation(is_string($attribute) ? $attribute : '', $value);
-            $flattenedObjectKey = array_key_first($flattendQuery);
-            $queryValue = $flattendQuery[$flattenedObjectKey];
-            $queryAttribute = $query->getAttribute();
-            $flattenedQueryField = array_key_first($flattendQuery);
-            $flattenedObjectKey = $flattenedQueryField === '' ? $queryAttribute : $queryAttribute . '.' . array_key_first($flattendQuery);
-            switch ($query->getMethod()) {
-
-                case Query::TYPE_CONTAINS:
-                case Query::TYPE_CONTAINS_ANY:
-                case Query::TYPE_CONTAINS_ALL:
-                case Query::TYPE_NOT_CONTAINS: {
-                    $arrayValue = \is_array($queryValue) ? $queryValue : [$queryValue];
-                    $operator = $isNot ? '$nin' : '$in';
-                    $conditions[] = [ $flattenedObjectKey => [ $operator => $arrayValue] ];
-                    break;
-                }
-
-                case Query::TYPE_EQUAL:
-                case Query::TYPE_NOT_EQUAL: {
-                    if (\is_array($queryValue)) {
-                        $operator = $isNot ? '$nin' : '$in';
-                        $conditions[] = [ $flattenedObjectKey => [ $operator => $queryValue] ];
-                    } else {
-                        $operator = $isNot ? '$ne' : '$eq';
-                        $conditions[] = [ $flattenedObjectKey => [ $operator => $queryValue] ];
-                    }
-
-                    break;
-                }
-            }
-        }
-
-        $logicalOperator = $isNot ? '$and' : '$or';
-        if (count($conditions) && isset($filter[$logicalOperator])) {
-            $filter[$logicalOperator] = array_merge($filter[$logicalOperator], $conditions);
-        } else {
-            $filter[$logicalOperator] = $conditions;
-        }
+        return Database::MAX_BIG_INT;
     }
 
     /**
-     * Flatten a nested associative array into Mongo-style dot notation.
-     *
-     * @param string $key
-     * @param mixed $value
-     * @param string $prefix
-     * @return array<string, mixed>
+     * Get maximum column limit.
+     * Returns 0 to indicate no limit
      */
-    private function flattenWithDotNotation(string $key, mixed $value, string $prefix = ''): array
+    public function getLimitForAttributes(): int
     {
-        /** @var array<string, mixed> $result */
-        $result = [];
-
-        $stack = [];
-
-        $initialKey = $prefix === '' ? $key : $prefix . '.' . $key;
-        $stack[] = [$initialKey, $value];
-        while (!empty($stack)) {
-            [$currentPath, $currentValue] = array_pop($stack);
-            if (is_array($currentValue) && !array_is_list($currentValue)) {
-                foreach ($currentValue as $nextKey => $nextValue) {
-                    $nextKey = (string)$nextKey;
-                    $nextPath = $currentPath === '' ? $nextKey : $currentPath . '.' . $nextKey;
-                    $stack[] = [$nextPath,  $nextValue];
-                }
-            } else {
-                // leaf node
-                $result[$currentPath] = $currentValue;
-            }
-        }
+        return 0;
+    }
 
-        return $result;
+    /**
+     * Get maximum index limit.
+     * https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Number-of-Indexes-per-Collection
+     */
+    public function getLimitForIndexes(): int
+    {
+        return 64;
     }
 
     /**
-     * Get Query Operator
-     *
-     * @param string $operator
+     * Get the maximum combined index key length in bytes.
      *
-     * @return string
-     * @throws Exception
+     * @return int
      */
-    protected function getQueryOperator(string $operator): string
+    public function getMaxIndexLength(): int
     {
-        return match ($operator) {
-            Query::TYPE_EQUAL,
-            Query::TYPE_IS_NULL => '$eq',
-            Query::TYPE_NOT_EQUAL,
-            Query::TYPE_IS_NOT_NULL => '$ne',
-            Query::TYPE_LESSER => '$lt',
-            Query::TYPE_LESSER_EQUAL => '$lte',
-            Query::TYPE_GREATER => '$gt',
-            Query::TYPE_GREATER_EQUAL => '$gte',
-            Query::TYPE_CONTAINS => '$in',
-            Query::TYPE_CONTAINS_ANY => '$in',
-            Query::TYPE_CONTAINS_ALL => '$all',
-            Query::TYPE_NOT_CONTAINS => 'notContains',
-            Query::TYPE_SEARCH => '$search',
-            Query::TYPE_NOT_SEARCH => '$search',
-            Query::TYPE_BETWEEN => 'between',
-            Query::TYPE_NOT_BETWEEN => 'notBetween',
-            Query::TYPE_STARTS_WITH,
-            Query::TYPE_NOT_STARTS_WITH,
-            Query::TYPE_ENDS_WITH,
-            Query::TYPE_NOT_ENDS_WITH,
-            Query::TYPE_REGEX => '$regex',
-            Query::TYPE_OR => '$or',
-            Query::TYPE_AND => '$and',
-            Query::TYPE_EXISTS,
-            Query::TYPE_NOT_EXISTS => '$exists',
-            Query::TYPE_ELEM_MATCH => '$elemMatch',
-            default => throw new DatabaseException('Unknown operator:' . $operator . '. Must be one of ' . Query::TYPE_EQUAL . ', ' . Query::TYPE_NOT_EQUAL . ', ' . Query::TYPE_LESSER . ', ' . Query::TYPE_LESSER_EQUAL . ', ' . Query::TYPE_GREATER . ', ' . Query::TYPE_GREATER_EQUAL . ', ' . Query::TYPE_IS_NULL . ', ' . Query::TYPE_IS_NOT_NULL . ', ' . Query::TYPE_BETWEEN . ', ' . Query::TYPE_NOT_BETWEEN . ', ' . Query::TYPE_STARTS_WITH . ', ' . Query::TYPE_NOT_STARTS_WITH . ', ' . Query::TYPE_ENDS_WITH . ', ' . Query::TYPE_NOT_ENDS_WITH . ', ' . Query::TYPE_CONTAINS . ', ' . Query::TYPE_NOT_CONTAINS . ', ' . Query::TYPE_SEARCH . ', ' . Query::TYPE_NOT_SEARCH . ', ' . Query::TYPE_SELECT),
-        };
+        return 1024;
     }
 
-    protected function getQueryValue(string $method, mixed $value): mixed
+    /**
+     * Get the maximum VARCHAR length. MongoDB has no distinction, so returns the same as string limit.
+     *
+     * @return int
+     */
+    public function getMaxVarcharLength(): int
     {
-        switch ($method) {
-            case Query::TYPE_STARTS_WITH:
-                $value = preg_quote($value, '/');
-                return $value . '.*';
-            case Query::TYPE_NOT_STARTS_WITH:
-                return $value;
-            case Query::TYPE_ENDS_WITH:
-                $value = preg_quote($value, '/');
-                return '.*' . $value;
-            case Query::TYPE_NOT_ENDS_WITH:
-                return $value;
-            default:
-                return $value;
-        }
+        return 2147483647;
     }
 
     /**
-     * Get Mongo Order
-     *
-     * @param string $order
+     * Get the maximum length for unique document IDs.
      *
      * @return int
-     * @throws Exception
      */
-    protected function getOrder(string $order): int
+    public function getMaxUIDLength(): int
     {
-        return match (\strtoupper($order)) {
-            Database::ORDER_ASC => 1,
-            Database::ORDER_DESC => -1,
-            default => throw new DatabaseException('Unknown sort order:' . $order . '. Must be one of ' . Database::ORDER_ASC . ', ' . Database::ORDER_DESC),
-        };
+        return 255;
     }
 
     /**
-     * Check if tenant should be added to index
+     * Get the minimum supported datetime value for MongoDB.
      *
-     * @param Document|string $indexOrType Index document or index type string
-     * @return bool
+     * @return NativeDateTime
      */
-    protected function shouldAddTenantToIndex(Document|string $indexOrType): bool
+    public function getMinDateTime(): NativeDateTime
     {
-        if (!$this->sharedTables) {
-            return false;
-        }
-
-        $indexType = $indexOrType instanceof Document
-            ? $indexOrType->getAttribute('type')
-            : $indexOrType;
-
-        return $indexType !== Database::INDEX_TTL;
+        return new NativeDateTime('-9999-01-01 00:00:00');
     }
 
     /**
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
+     * Get current attribute count from collection document
      */
-    protected function getAttributeProjection(array $selections, string $prefix = ''): mixed
+    public function getCountOfAttributes(Document $collection): int
     {
-        $projection = [];
-
-        $internalKeys = \array_map(
-            fn ($attr) => $attr['$id'],
-            Database::INTERNAL_ATTRIBUTES
-        );
-
-        foreach ($selections as $selection) {
-            // Skip internal attributes since all are selected by default
-            if (\in_array($selection, $internalKeys)) {
-                continue;
-            }
-
-            $projection[$selection] = 1;
-        }
-
-        $projection['_uid'] = 1;
-        $projection['_id'] = 1;
-        $projection['_createdAt'] = 1;
-        $projection['_updatedAt'] = 1;
-        $projection['_permissions'] = 1;
+        $rawAttrCount = $collection->getAttribute('attributes');
+        $attrArray = \is_array($rawAttrCount) ? $rawAttrCount : [];
+        $attributes = \count($attrArray);
 
-        return $projection;
+        return $attributes + static::getCountOfDefaultAttributes();
     }
 
     /**
-     * Get max STRING limit
-     *
-     * @return int
+     * Get current index count from collection document
      */
-    public function getLimitForString(): int
+    public function getCountOfIndexes(Document $collection): int
     {
-        return 2147483647;
-    }
+        $rawIdxCount = $collection->getAttribute('indexes');
+        $idxArray = \is_array($rawIdxCount) ? $rawIdxCount : [];
+        $indexes = \count($idxArray);
 
-    /**
-     * Get max VARCHAR limit
-     * MongoDB doesn't distinguish between string types, so using same as string limit
-     *
-     * @return int
-     */
-    public function getMaxVarcharLength(): int
-    {
-        return 2147483647;
+        return $indexes + static::getCountOfDefaultIndexes();
     }
 
     /**
-     * Get max INT limit
-     *
-     * @return int
+     * Returns number of attributes used by default.
+     *p
      */
-    public function getLimitForInt(): int
+    public function getCountOfDefaultAttributes(): int
     {
-        // Mongo does not handle integers directly, so using MariaDB limit for now
-        return 4294967295;
+        return \count(Database::internalAttributes());
     }
 
     /**
-     * Get max BIGINT limit
-     *
-     * @return int
+     * Returns number of indexes used by default.
      */
-    public function getLimitForBigInt(): int
+    public function getCountOfDefaultIndexes(): int
     {
-        return Database::MAX_BIG_INT;
+        return \count(Database::INTERNAL_INDEXES);
     }
 
     /**
-     * Get maximum column limit.
-     * Returns 0 to indicate no limit
-     *
-     * @return int
+     * Get maximum width, in bytes, allowed for a SQL row
+     * Return 0 when no restrictions apply
      */
-    public function getLimitForAttributes(): int
+    public function getDocumentSizeLimit(): int
     {
         return 0;
     }
 
     /**
-     * Get maximum index limit.
-     * https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Number-of-Indexes-per-Collection
-     *
-     * @return int
-     */
-    public function getLimitForIndexes(): int
-    {
-        return 64;
-    }
-
-    public function getMinDateTime(): \DateTime
-    {
-        return new \DateTime('-9999-01-01 00:00:00');
-    }
-
-    /**
-     * Is schemas supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemas(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForIndex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForIndexArray(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Is internal casting supported?
-     *
-     * @return bool
+     * Estimate maximum number of bytes required to store a document in $collection.
+     * Byte requirement varies based on column type and size.
+     * Needed to satisfy MariaDB/MySQL row width limit.
+     * Return 0 when no restrictions apply to row width
      */
-    public function getSupportForInternalCasting(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUTCCasting(): bool
-    {
-        return true;
-    }
-
-    public function setUTCDatetime(string $value): mixed
+    public function getAttributeWidth(Document $collection): int
     {
-        return new UTCDateTime(new \DateTime($value));
+        return 0;
     }
 
-
     /**
-     * Are attributes supported?
+     * Get reserved keywords that cannot be used as identifiers. MongoDB has none.
      *
-     * @return bool
+     * @return array<string>
      */
-    public function getSupportForAttributes(): bool
-    {
-        return $this->supportForAttributes;
-    }
-
-    public function setSupportForAttributes(bool $support): bool
+    public function getKeywords(): array
     {
-        $this->supportForAttributes = $support;
-        return $this->supportForAttributes;
+        return [];
     }
 
     /**
-     * Is unique index supported?
+     * Get the keys of internally managed indexes. MongoDB has none exposed.
      *
-     * @return bool
+     * @return array<string>
      */
-    public function getSupportForUniqueIndex(): bool
+    public function getInternalIndexesKeys(): array
     {
-        return true;
+        return [];
     }
 
     /**
-     * Is fulltext index supported?
+     * Get the internal ID attribute type used by MongoDB (UUID v7).
      *
-     * @return bool
+     * @return string
      */
-    public function getSupportForFulltextIndex(): bool
+    public function getIdAttributeType(): string
     {
-        return true;
+        return ColumnType::Uuid7->value;
     }
 
     /**
-     * Is fulltext Wildcard index supported?
+     * Get the query to check for tenant when in shared tables mode
      *
-     * @return bool
+     * @param  string  $collection  The collection being queried
+     * @param  string  $alias  The alias of the parent collection if in a subquery
      */
-    public function getSupportForFulltextWildcardIndex(): bool
+    public function getTenantQuery(string $collection, string $alias = ''): string
     {
-        return false;
+        return '';
     }
 
     /**
-     * Does the adapter handle Query Array Contains?
+     * Check whether the adapter supports storing non-UTF characters. MongoDB does not.
      *
      * @return bool
      */
-    public function getSupportForQueryContains(): bool
+    public function getSupportNonUtfCharacters(): bool
     {
         return false;
     }
 
     /**
-     * Are timeouts supported?
+     * Get Collection Size of raw data
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForTimeouts(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForRelationships(): bool
+    public function getSizeOfCollection(string $collection): int
     {
-        return true;
-    }
+        $namespace = $this->getNamespace();
+        $collection = $this->filter($collection);
+        $collection = $namespace.'_'.$collection;
 
-    public function getSupportForUpdateLock(): bool
-    {
-        return false;
-    }
+        $command = [
+            'collStats' => $collection,
+            'scale' => 1,
+        ];
 
-    public function getSupportForAttributeResizing(): bool
-    {
-        return false;
+        try {
+            /** @var \stdClass $result */
+            $result = $this->getClient()->query($command);
+            if (isset($result->totalSize)) {
+                /** @var mixed $totalSizeVal */
+                $totalSizeVal = $result->totalSize;
+                return \is_int($totalSizeVal) ? $totalSizeVal : (\is_numeric($totalSizeVal) ? (int) $totalSizeVal : 0);
+            } else {
+                throw new DatabaseException('No size found');
+            }
+        } catch (Exception $e) {
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
+        }
     }
 
     /**
-     * Are batch operations supported?
+     * Get Collection Size on disk
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForBatchOperations(): bool
+    public function getSizeOfCollectionOnDisk(string $collection): int
     {
-        return false;
+        return $this->getSizeOfCollection($collection);
     }
 
     /**
-     * Is get connection id supported?
-     *
-     * @return bool
+     * @param  array<int|string>  $tenants
+     * @return int|string|null|array<string, array<int|string|null>>
      */
-    public function getSupportForGetConnectionId(): bool
-    {
-        return false;
-    }
+    public function getTenantFilters(
+        string $collection,
+        array $tenants = [],
+    ): int|string|null|array {
+        if (! $this->sharedTables) {
+            return null;
+        }
 
-    /**
-     * Is PCRE regex supported?
-     *
-     * @return bool
-     */
-    public function getSupportForPCRERegex(): bool
-    {
-        return true;
-    }
+        /** @var array<int|string> $values */
+        $values = [];
 
-    /**
-     * Is POSIX regex supported?
-     *
-     * @return bool
-     */
-    public function getSupportForPOSIXRegex(): bool
-    {
-        return false;
-    }
+        if (\count($tenants) === 0) {
+            $tenant = $this->getTenant();
+            if ($tenant !== null) {
+                $values[] = $tenant;
+            }
+        } else {
+            for ($index = 0; $index < \count($tenants); $index++) {
+                $values[] = $tenants[$index];
+            }
+        }
 
-    /**
-     * Is cache fallback supported?
-     *
-     * @return bool
-     */
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return false;
-    }
+        if ($collection === Database::METADATA && !empty($values)) {
+            // Include both tenant-specific and tenant-null documents for metadata collections
+            // by returning the $in filter which covers tenant documents
+            // (null tenant docs are accessible to all tenants for metadata)
+            return ['$in' => [...$values, null]];
+        }
 
-    public function getSupportForCaching(): bool
-    {
-        return true;
-    }
+        if (empty($values)) {
+            return null;
+        }
 
-    /**
-     * Is hostname supported?
-     *
-     * @return bool
-     */
-    public function getSupportForHostname(): bool
-    {
-        return true;
+        if (\count($values) === 1) {
+            return $values[0];
+        }
+
+        return ['$in' => $values];
     }
 
     /**
-     * Is get schema attributes supported?
+     * Returns the document after casting to
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCastIndexArray(): bool
+    public function castingBefore(Document $collection, Document $document): Document
     {
-        return false;
-    }
+        if ($document->isEmpty()) {
+            return $document;
+        }
 
-    public function getSupportForUpserts(): bool
-    {
-        return true;
-    }
+        $rawCbAttributes = $collection->getAttribute('attributes', []);
+        /** @var array<int, array<string, mixed>> $cbAttributes */
+        $cbAttributes = \is_array($rawCbAttributes) ? $rawCbAttributes : [];
 
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return false;
-    }
+        $internalCbAttributeArrays = \array_map(
+            fn (Attribute $a) => [Document::ID => $a->key, 'type' => $a->type, 'array' => $a->array],
+            Database::internalAttributes()
+        );
 
-    public function getSupportForReconnection(): bool
-    {
-        return false;
-    }
+        /** @var array<int, array<string, mixed>> $attributes */
+        $attributes = \array_merge($cbAttributes, $internalCbAttributeArrays);
 
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawCbId = $attribute[Document::ID] ?? null;
+            $key = \is_string($rawCbId) ? $rawCbId : '';
+            $rawCbType = $attribute['type'] ?? null;
+            $type = $rawCbType instanceof ColumnType
+                ? $rawCbType
+                : (\is_string($rawCbType) ? Attribute::tryNormalizeType($rawCbType) : null);
+            $array = (bool) ($attribute['array'] ?? false);
 
-    public function getSupportForObject(): bool
-    {
-        return true;
-    }
+            $value = $document->getAttribute($key);
+            if (is_null($value)) {
+                continue;
+            }
 
-    /**
-     * Are object (JSON) indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
-    }
+            if (Operator::isOperator($value)) {
+                if (Attribute::isIntegerType($type ?? ColumnType::String)) {
+                    /** @var Operator $value */
+                    $values = $value->getValues();
+                    foreach ($values as $index => $operand) {
+                        if (! \is_string($operand) || ! BigInt::isIntegerString($operand)) {
+                            continue;
+                        }
+                        if (! BigInt::fitsPhpInt($operand)) {
+                            throw new TypeException('MongoDB cannot safely apply an integer operator outside the signed 64-bit range.');
+                        }
+                        $values[$index] = (int) $operand;
+                    }
+                    $value->setValues($values);
+                }
+                continue;
+            }
+
+            if ($array) {
+                if (is_string($value)) {
+                    $decoded = json_decode($value, true);
+                    if (json_last_error() !== JSON_ERROR_NONE) {
+                        throw new DatabaseException('Failed to decode JSON for attribute '.$key.': '.json_last_error_msg());
+                    }
+                    $value = $decoded;
+                }
+                if (!\is_array($value)) {
+                    $value = [$value];
+                }
+            } else {
+                $value = [$value];
+            }
+
+            /** @var array<mixed> $value */
+            foreach ($value as &$node) {
+                switch ($type) {
+                    case ColumnType::Datetime:
+                        if (! ($node instanceof UTCDateTime)) {
+                            /** @var mixed $node */
+                            $nodeStr = \is_string($node) ? $node : (\is_scalar($node) ? (string) $node : '');
+                            if (\is_numeric($nodeStr)) {
+                                $node = new UTCDateTime((int) $nodeStr);
+                            } else {
+                                $node = new UTCDateTime(new NativeDateTime($nodeStr));
+                            }
+                        }
+                        break;
+                    case ColumnType::Object:
+                        /** @var mixed $node */
+                        $nodeStr = \is_string($node) ? $node : (\is_scalar($node) ? (string) $node : '');
+                        $node = json_decode($nodeStr);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            unset($node);
+            $document->setAttribute($key, ($array) ? $value : $value[0]);
+        }
+        $rawIndexesAttr = $collection->getAttribute('indexes');
+        /** @var array<mixed> $indexes */
+        $indexes = \is_array($rawIndexesAttr) ? $rawIndexesAttr : [];
+        /** @var array<string> $ttlIndexes */
+        $ttlIndexes = array_filter($indexes, function ($index) {
+            if ($index instanceof Document) {
+                return $index->getAttribute('type') === IndexType::Ttl->value;
+            }
+            return false;
+        });
+
+        if (! $this->supports(Capability::DefinedAttributes)) {
+            foreach ($document->getArrayCopy() as $key => $value) {
+                $key = (string) $key;
+                if (in_array($this->getInternalKeyForAttribute($key), Database::INTERNAL_ATTRIBUTE_KEYS)) {
+                    continue;
+                }
+                if (is_string($value) && (in_array($key, $ttlIndexes) || $this->isExtendedISODatetime($value))) {
+                    try {
+                        $newValue = new UTCDateTime(new NativeDateTime($value));
+                        $document->setAttribute($key, $newValue);
+                    } catch (Throwable $th) {
+                        // skip -> a valid string
+                    }
+                }
+            }
+        }
+
+        return $document;
+    }
 
     /**
-     * Get current attribute count from collection document
+     * Returns the document after casting from
+     */
+    public function castingAfter(Document $collection, Document $document): Document
+    {
+        if ($document->isEmpty()) {
+            return $document;
+        }
+
+        $rawCollectionAttributes = $collection->getAttribute('attributes', []);
+        /** @var array<int, array<string, mixed>> $collectionAttributes */
+        $collectionAttributes = \is_array($rawCollectionAttributes) ? $rawCollectionAttributes : [];
+
+        $internalAttributeArrays = \array_map(
+            fn (Attribute $a) => [Document::ID => $a->key, 'type' => $a->type, 'array' => $a->array],
+            Database::internalAttributes()
+        );
+
+        /** @var array<int, array<string, mixed>> $attributes */
+        $attributes = \array_merge($collectionAttributes, $internalAttributeArrays);
+
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawId = $attribute[Document::ID] ?? null;
+            $key = \is_string($rawId) ? $rawId : '';
+            $rawType = $attribute['type'] ?? null;
+            $type = $rawType instanceof ColumnType
+                ? $rawType
+                : (\is_string($rawType) ? Attribute::tryNormalizeType($rawType) : null);
+            $array = (bool) ($attribute['array'] ?? false);
+            $value = $document->getAttribute($key);
+            if (is_null($value)) {
+                continue;
+            }
+
+            if (Operator::isOperator($value)) {
+                continue;
+            }
+
+            if ($array) {
+                if (is_string($value)) {
+                    $decoded = json_decode($value, true);
+                    if (json_last_error() !== JSON_ERROR_NONE) {
+                        throw new DatabaseException('Failed to decode JSON for attribute '.$key.': '.json_last_error_msg());
+                    }
+                    $value = $decoded;
+                }
+                if (!\is_array($value)) {
+                    $value = [$value];
+                }
+            } else {
+                $value = [$value];
+            }
+
+            /** @var array<mixed> $value */
+            foreach ($value as &$node) {
+                switch ($type) {
+                    case ColumnType::BigInteger:
+                    case ColumnType::BigSerial:
+                    case ColumnType::Integer:
+                        $node = \is_int($node)
+                            ? $node
+                            : ($node instanceof Int64
+                                ? (int) (string) $node
+                                : (\is_numeric($node) ? (int) $node : 0));
+                        break;
+                    case ColumnType::String:
+                    case ColumnType::Id:
+                        $node = \is_string($node) ? $node : (\is_scalar($node) ? (string) $node : $node);
+                        break;
+                    case ColumnType::Float:
+                    case ColumnType::Double:
+                        $node = \is_float($node) ? $node : (\is_numeric($node) ? (float) $node : 0.0);
+                        break;
+                    case ColumnType::Boolean:
+                        $node = \is_scalar($node) ? (bool) $node : $node;
+                        break;
+                    case ColumnType::Datetime:
+                        $node = $this->convertUTCDateToString($node);
+                        break;
+                    case ColumnType::Object:
+                        // Convert stdClass objects to arrays for object attributes
+                        if (is_object($node) && get_class($node) === stdClass::class) {
+                            $node = $this->convertStdClassToArray($node);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+            unset($node);
+            $document->setAttribute($key, ($array) ? $value : $value[0]);
+        }
+
+        if (! $this->supports(Capability::DefinedAttributes)) {
+            foreach ($document->getArrayCopy() as $key => $value) {
+                // mongodb results out a stdclass for objects
+                if (is_object($value) && get_class($value) === stdClass::class) {
+                    $document->setAttribute($key, $this->convertStdClassToArray($value));
+                } elseif ($value instanceof UTCDateTime) {
+                    $document->setAttribute($key, $this->convertUTCDateToString($value));
+                }
+            }
+        }
+
+        return $document;
+    }
+
+    /**
+     * Convert a datetime string to a MongoDB UTCDateTime object.
      *
-     * @param Document $collection
-     * @return int
+     * @param string $value The datetime string
+     * @return mixed
      */
-    public function getCountOfAttributes(Document $collection): int
+    public function setUTCDatetime(string $value): mixed
     {
-        $attributes = \count($collection->getAttribute('attributes') ?? []);
+        return new UTCDateTime(new NativeDateTime($value));
+    }
 
-        return $attributes + static::getCountOfDefaultAttributes();
+    /**
+     * Escape a field name for MongoDB storage.
+     * MongoDB field names cannot start with $ or contain dots.
+     */
+    protected function escapeMongoFieldName(string $name): string
+    {
+        if (\str_starts_with($name, '$')) {
+            $name = '_'.\substr($name, 1);
+        }
+        if (\str_contains($name, '.')) {
+            $name = \str_replace('.', '__dot__', $name);
+        }
+
+        return $name;
     }
 
     /**
-     * Get current index count from collection document
+     * Escape query attribute names that contain dots and match known collection attributes.
+     * This distinguishes field names with dots (like 'collectionSecurity.Parent') from
+     * nested object paths (like 'profile.level1.value').
      *
-     * @param Document $collection
-     * @return int
+     * @param  array<Query>  $queries
      */
-    public function getCountOfIndexes(Document $collection): int
+    protected function escapeQueryAttributes(Document $collection, array $queries): void
     {
-        $indexes = \count($collection->getAttribute('indexes') ?? []);
+        $rawAttrs = $collection->getAttribute('attributes', []);
+        /** @var array<array<string, mixed>> $attributes */
+        $attributes = \is_array($rawAttrs) ? $rawAttrs : [];
+        $dotAttributes = [];
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawKey = $attribute[Document::ID] ?? null;
+            $key = \is_string($rawKey) ? $rawKey : (\is_scalar($rawKey) ? (string) $rawKey : '');
+            if (\str_contains($key, '.') || \str_starts_with($key, '$')) {
+                $dotAttributes[$key] = $this->escapeMongoFieldName($key);
+            }
+        }
 
-        return $indexes + static::getCountOfDefaultIndexes();
+        if (empty($dotAttributes)) {
+            return;
+        }
+
+        foreach ($queries as $query) {
+            $attr = $query->getAttribute();
+            if (isset($dotAttributes[$attr])) {
+                $query->setAttribute($dotAttributes[$attr]);
+            }
+        }
     }
 
     /**
-     * Returns number of attributes used by default.
-     *p
-     * @return int
+     * Ensure relationship attributes have default null values in MongoDB documents.
+     * MongoDB doesn't store null fields, so we need to add them for schema compatibility.
      */
-    public function getCountOfDefaultAttributes(): int
+    protected function ensureRelationshipDefaults(Document $collection, Document $document): void
     {
-        return \count(Database::INTERNAL_ATTRIBUTES);
+        $rawEnsureAttrs = $collection->getAttribute('attributes', []);
+        /** @var array<array<string, mixed>> $attributes */
+        $attributes = \is_array($rawEnsureAttrs) ? $rawEnsureAttrs : [];
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawEnsureKey = $attribute[Document::ID] ?? null;
+            $key = \is_string($rawEnsureKey) ? $rawEnsureKey : (\is_scalar($rawEnsureKey) ? (string) $rawEnsureKey : '');
+            $rawEnsureType = $attribute['type'] ?? null;
+            $type = \is_string($rawEnsureType) ? $rawEnsureType : (\is_scalar($rawEnsureType) ? (string) $rawEnsureType : '');
+            if ($type === ColumnType::Relationship->value && ! $document->offsetExists($key)) {
+                $rawOptions = $attribute['options'] ?? [];
+                /** @var array<string, mixed> $options */
+                $options = \is_array($rawOptions) ? $rawOptions : [];
+                $twoWay = (bool) ($options['twoWay'] ?? false);
+                $rawSide = $options['side'] ?? null;
+                $side = \is_string($rawSide) ? $rawSide : (\is_scalar($rawSide) ? (string) $rawSide : '');
+                $rawRelationType = $options['relationType'] ?? null;
+                $relationType = \is_string($rawRelationType) ? $rawRelationType : (\is_scalar($rawRelationType) ? (string) $rawRelationType : '');
+
+                // Determine if this relationship stores data on this collection's documents
+                // Only set null defaults for relationships that would have a column in SQL
+                $storesData = match ($relationType) {
+                    RelationType::OneToOne->value => $side === RelationSide::Parent->value || $twoWay,
+                    RelationType::OneToMany->value => $side === RelationSide::Child->value,
+                    RelationType::ManyToOne->value => $side === RelationSide::Parent->value,
+                    RelationType::ManyToMany->value => false,
+                    default => false,
+                };
+
+                if ($storesData) {
+                    $document->setAttribute($key, null);
+                }
+            }
+        }
     }
 
     /**
-     * Returns number of indexes used by default.
+     * Keys cannot begin with $ in MongoDB
+     * Convert $ prefix to _ on $id, $permissions, and $collection
      *
-     * @return int
+     * @param  array<string, mixed>  $array
+     * @return array<string, mixed>
      */
-    public function getCountOfDefaultIndexes(): int
+    protected function replaceChars(string $from, string $to, array $array): array
     {
-        return \count(Database::INTERNAL_INDEXES);
+        $filter = [
+            \substr(Document::PERMISSIONS, 1),
+            \substr(Document::CREATED_AT, 1),
+            \substr(Document::UPDATED_AT, 1),
+            \substr(Document::COLLECTION, 1),
+            \substr(Document::VERSION, 1),
+        ];
+
+        // First pass: recursively process array values and collect keys to rename
+        $keysToRename = [];
+        foreach ($array as $k => $v) {
+            if (is_array($v)) {
+                /** @var array<string, mixed> $v */
+                $array[$k] = $this->replaceChars($from, $to, $v);
+            }
+
+            $newKey = $k;
+
+            // Handle key replacement for filtered attributes
+            $clean_key = str_replace($from, '', $k);
+            if (in_array($clean_key, $filter)) {
+                $newKey = str_replace($from, $to, $k);
+            } elseif (\str_starts_with($k, $from) && ! in_array($k, [Document::ID, Document::SEQUENCE, Document::TENANT, Storage::UID, Storage::SEQUENCE, Storage::TENANT])) {
+                // Handle any other key starting with the 'from' char (e.g. user-defined $-prefixed keys)
+                $newKey = $to.\substr($k, \strlen($from));
+            }
+
+            // Handle dot escaping in MongoDB field names
+            if ($from === '$' && \str_contains($newKey, '.')) {
+                $newKey = \str_replace('.', '__dot__', $newKey);
+            } elseif ($from === '_' && \str_contains($k, '__dot__')) {
+                $newKey = \str_replace('__dot__', '.', $newKey);
+            }
+
+            if ($newKey !== $k) {
+                $keysToRename[$k] = $newKey;
+            }
+        }
+
+        foreach ($keysToRename as $oldKey => $newKey) {
+            $array[$newKey] = $array[$oldKey];
+            unset($array[$oldKey]);
+        }
+
+        // Handle special attribute mappings
+        if ($from === '_') {
+            if (isset($array[Storage::SEQUENCE])) {
+                $array[Document::SEQUENCE] = $this->stringifyIdentifier($array[Storage::SEQUENCE]);
+                unset($array[Storage::SEQUENCE]);
+            }
+            if (isset($array[Storage::UID])) {
+                $array[Document::ID] = $this->stringifyIdentifier($array[Storage::UID]);
+                unset($array[Storage::UID]);
+            }
+            if (isset($array[Storage::TENANT])) {
+                $tenant = $array[Storage::TENANT];
+                $array[Document::TENANT] = \is_int($tenant) ? $tenant : $this->stringifyIdentifier($tenant);
+                unset($array[Storage::TENANT]);
+            }
+        } elseif ($from === '$') {
+            if (isset($array[Document::ID])) {
+                $array[Storage::UID] = $array[Document::ID];
+                unset($array[Document::ID]);
+            }
+            if (isset($array[Document::SEQUENCE])) {
+                $array[Storage::SEQUENCE] = $array[Document::SEQUENCE];
+                unset($array[Document::SEQUENCE]);
+            }
+            if (isset($array[Document::TENANT])) {
+                $array[Storage::TENANT] = $array[Document::TENANT];
+                unset($array[Document::TENANT]);
+            }
+        }
+
+        return $array;
+    }
+
+    private function stringifyIdentifier(mixed $value): string
+    {
+        if (\is_string($value)) {
+            return $value;
+        }
+
+        if (\is_scalar($value)) {
+            return (string) $value;
+        }
+
+        if (\is_object($value) && \method_exists($value, '__toString')) {
+            return (string) $value;
+        }
+
+        return '';
     }
 
     /**
-     * Get maximum width, in bytes, allowed for a SQL row
-     * Return 0 when no restrictions apply
+     * @param  array<Query>  $queries
+     * @return array<mixed>
      *
-     * @return int
+     * @throws Exception
      */
-    public function getDocumentSizeLimit(): int
+    protected function buildFilters(array $queries, string $separator = '$and'): array
     {
-        return 0;
+        $filters = [];
+        $queries = Query::groupForDatabase($queries)['filters'];
+
+        foreach ($queries as $query) {
+            /* @var $query Query */
+            if ($query->isNested()) {
+                if ($query->getMethod() === Method::ElemMatch) {
+                    /** @var array<Query> $elemMatchValues */
+                    $elemMatchValues = $query->getValues();
+                    $filters[$separator][] = [
+                        $query->getAttribute() => [
+                            '$elemMatch' => $this->buildFilters($elemMatchValues, $separator),
+                        ],
+                    ];
+
+                    continue;
+                }
+
+                $operator = $this->getQueryOperator($query->getMethod());
+
+                /** @var array<Query> $nestedValues */
+                $nestedValues = $query->getValues();
+                $filters[$separator][] = $this->buildFilters($nestedValues, $operator);
+            } else {
+                $filters[$separator][] = $this->buildFilter($query);
+            }
+        }
+
+        return $filters;
     }
 
     /**
-     * Estimate maximum number of bytes required to store a document in $collection.
-     * Byte requirement varies based on column type and size.
-     * Needed to satisfy MariaDB/MySQL row width limit.
-     * Return 0 when no restrictions apply to row width
+     * @return array<mixed>
      *
-     * @param Document $collection
-     * @return int
+     * @throws Exception
      */
-    public function getAttributeWidth(Document $collection): int
+    protected function buildFilter(Query $query): array
     {
-        return 0;
-    }
+        // Normalize extended ISO 8601 datetime strings in query values to UTCDateTime
+        // so they can be correctly compared against datetime fields stored in MongoDB.
+        if (! $this->supports(Capability::DefinedAttributes) || \in_array($query->getAttribute(), [Document::CREATED_AT, Document::UPDATED_AT], true)) {
+            $values = $query->getValues();
+            foreach ($values as $k => $value) {
+                if (is_string($value) && $this->isExtendedISODatetime($value)) {
+                    try {
+                        $values[$k] = $this->toMongoDatetime($value);
+                    } catch (Throwable $th) {
+                        // Leave value as-is if it cannot be parsed as a datetime
+                    }
+                }
+            }
+            $query->setValues($values);
+        }
+
+        if ($query->getAttribute() === Document::ID) {
+            $query->setAttribute(Storage::UID);
+        } elseif ($query->getAttribute() === Document::SEQUENCE) {
+            $query->setAttribute(Storage::SEQUENCE);
+            $values = $query->getValues();
+            foreach ($values as $k => $v) {
+                $values[$k] = $v;
+            }
+            $query->setValues($values);
+        } elseif ($query->getAttribute() === Document::CREATED_AT) {
+            $query->setAttribute(Storage::CREATED_AT);
+        } elseif ($query->getAttribute() === Document::UPDATED_AT) {
+            $query->setAttribute(Storage::UPDATED_AT);
+        } elseif (\str_starts_with($query->getAttribute(), '$')) {
+            // Escape $ prefix and dots in user-defined $-prefixed attribute names for MongoDB
+            $query->setAttribute($this->escapeMongoFieldName($query->getAttribute()));
+        }
+
+        $attribute = $query->getAttribute();
+        $operator = $this->getQueryOperator($query->getMethod());
+
+        $value = match ($query->getMethod()) {
+            Method::IsNull,
+            Method::IsNotNull => null,
+            Method::Exists => true,
+            Method::NotExists => false,
+            default => $this->getQueryValue(
+                $query->getMethod(),
+                count($query->getValues()) > 1
+                    ? $query->getValues()
+                    : $query->getValues()[0]
+            ),
+        };
+
+        /** @var array<string, mixed> $filter */
+        $filter = [];
+        if ($query->isObjectAttribute() && ! \str_contains($attribute, '.') && in_array($query->getMethod(), [Method::Equal, Method::Contains, Method::ContainsAny, Method::ContainsAll, Method::NotContains, Method::NotEqual])) {
+            $this->handleObjectFilters($query, $filter);
+
+            return $filter;
+        }
+
+        if ($operator == '$eq' && \is_array($value)) {
+            /** @var array<string, mixed> $attrFilter1 */
+            $attrFilter1 = [];
+            $attrFilter1['$in'] = $value;
+            $filter[$attribute] = $attrFilter1;
+        } elseif ($operator == '$ne' && \is_array($value)) {
+            /** @var array<string, mixed> $attrFilter2 */
+            $attrFilter2 = [];
+            $attrFilter2['$nin'] = $value;
+            $filter[$attribute] = $attrFilter2;
+        } elseif ($operator == '$all') {
+            /** @var array<string, mixed> $attrFilter3 */
+            $attrFilter3 = [];
+            $attrFilter3['$all'] = $query->getValues();
+            $filter[$attribute] = $attrFilter3;
+        } elseif ($operator == '$in') {
+            if (in_array($query->getMethod(), [Method::Contains, Method::ContainsAny]) && ! $query->onArray()) {
+                // contains support array values
+                if (is_array($value)) {
+                    $filter['$or'] = array_map(fn ($val) => [
+                        $attribute => [
+                            '$regex' => $this->createSafeRegex(
+                                \is_string($val) ? $val : (\is_scalar($val) ? (string) $val : ''),
+                                '.*%s.*',
+                                'i'
+                            ),
+                        ],
+                    ], $value);
+                } else {
+                    $valueStr = \is_string($value) ? $value : (\is_scalar($value) ? (string) $value : '');
+                    /** @var array<string, mixed> $attrFilter4 */
+                    $attrFilter4 = [];
+                    $attrFilter4['$regex'] = $this->createSafeRegex($valueStr, '.*%s.*');
+                    $filter[$attribute] = $attrFilter4;
+                }
+            } else {
+                /** @var array<string, mixed> $attrFilter5 */
+                $attrFilter5 = [];
+                $attrFilter5['$in'] = $query->getValues();
+                $filter[$attribute] = $attrFilter5;
+            }
+        } elseif ($operator === 'notContains') {
+            if (! $query->onArray()) {
+                $valueStr = \is_string($value) ? $value : (\is_scalar($value) ? (string) $value : '');
+                $filter[$attribute] = ['$not' => $this->createSafeRegex($valueStr, '.*%s.*')];
+            } else {
+                /** @var array<string, mixed> $attrFilter6 */
+                $attrFilter6 = [];
+                $attrFilter6['$nin'] = $query->getValues();
+                $filter[$attribute] = $attrFilter6;
+            }
+        } elseif ($operator == '$search') {
+            if ($query->getMethod() === Method::NotSearch) {
+                // MongoDB doesn't support negating $text expressions directly
+                // Use regex as fallback for NOT search while keeping fulltext for positive search
+                if (empty($value)) {
+                    // If value is not passed, don't add any filter - this will match all documents
+                } else {
+                    $valueStr = \is_string($value) ? $value : (\is_scalar($value) ? (string) $value : '');
+                    $filter[$attribute] = ['$not' => $this->createSafeRegex($valueStr, '.*%s.*')];
+                }
+            } else {
+                /** @var array<string, mixed> $textFilter */
+                $textFilter = \is_array($filter['$text'] ?? null) ? $filter['$text'] : [];
+                $textFilter[$operator] = $value;
+                $filter['$text'] = $textFilter;
+            }
+        } elseif ($query->getMethod() === Method::Between) {
+            /** @var array<mixed> $valueArray */
+            $valueArray = \is_array($value) ? $value : [];
+            /** @var array<string, mixed> $attrFilter7 */
+            $attrFilter7 = [];
+            $attrFilter7['$lte'] = $valueArray[1] ?? null;
+            $attrFilter7['$gte'] = $valueArray[0] ?? null;
+            $filter[$attribute] = $attrFilter7;
+        } elseif ($query->getMethod() === Method::NotBetween) {
+            /** @var array<mixed> $valueArray2 */
+            $valueArray2 = \is_array($value) ? $value : [];
+            $filter['$or'] = [
+                [$attribute => ['$lt' => $valueArray2[0] ?? null]],
+                [$attribute => ['$gt' => $valueArray2[1] ?? null]],
+            ];
+        } elseif ($operator === '$regex' && $query->getMethod() === Method::NotStartsWith) {
+            $valueStr = \is_string($value) ? $value : (\is_scalar($value) ? (string) $value : '');
+            $filter[$attribute] = ['$not' => $this->createSafeRegex($valueStr, '^%s')];
+        } elseif ($operator === '$regex' && $query->getMethod() === Method::NotEndsWith) {
+            $valueStr = \is_string($value) ? $value : (\is_scalar($value) ? (string) $value : '');
+            $filter[$attribute] = ['$not' => $this->createSafeRegex($valueStr, '%s$')];
+        } elseif ($operator === '$exists') {
+            /** @var array<mixed> $existsOr */
+            $existsOr = \is_array($filter['$or'] ?? null) ? $filter['$or'] : [];
+            foreach ($query->getValues() as $existsAttribute) {
+                $existsAttrStr = \is_string($existsAttribute) ? $existsAttribute : (\is_scalar($existsAttribute) ? (string) $existsAttribute : '');
+                $existsOr[] = [$existsAttrStr => [$operator => $value]];
+            }
+            $filter['$or'] = $existsOr;
+        } else {
+            /** @var array<string, mixed> $attrFilterDefault */
+            $attrFilterDefault = \is_array($filter[$attribute] ?? null) ? $filter[$attribute] : [];
+            $attrFilterDefault[$operator] = $value;
+            $filter[$attribute] = $attrFilterDefault;
+        }
 
-    /**
-     * Is casting supported?
-     *
-     * @return bool
-     */
-    public function getSupportForCasting(): bool
-    {
-        return false;
+        return $filter;
     }
 
     /**
-     * Is spatial attributes supported?
+     * Get Query Operator
      *
-     * @return bool
-     */
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Get Support for Null Values in Spatial Indexes
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForSpatialIndexNull(): bool
+    protected function getQueryOperator(Method $operator): string
     {
-        return false;
+        return match ($operator) {
+            Method::Equal,
+            Method::IsNull => '$eq',
+            Method::NotEqual,
+            Method::IsNotNull => '$ne',
+            Method::LessThan => '$lt',
+            Method::LessThanEqual => '$lte',
+            Method::GreaterThan => '$gt',
+            Method::GreaterThanEqual => '$gte',
+            Method::Contains => '$in',
+            Method::ContainsAny => '$in',
+            Method::ContainsAll => '$all',
+            Method::NotContains => 'notContains',
+            Method::Search => '$search',
+            Method::NotSearch => '$search',
+            Method::Between => 'between',
+            Method::NotBetween => 'notBetween',
+            Method::StartsWith,
+            Method::NotStartsWith,
+            Method::EndsWith,
+            Method::NotEndsWith,
+            Method::Regex => '$regex',
+            Method::Or => '$or',
+            Method::And => '$and',
+            Method::Exists,
+            Method::NotExists => '$exists',
+            Method::ElemMatch => '$elemMatch',
+            default => throw new DatabaseException('Unknown operator: '.$operator->value),
+        };
     }
 
-    /**
-     * Does the adapter support operators?
-     *
-     * @return bool
-     */
-    public function getSupportForOperators(): bool
+    protected function getQueryValue(Method $method, mixed $value): mixed
     {
-        return true;
+        return match ($method) {
+            Method::StartsWith => preg_quote(\is_string($value) ? $value : (\is_scalar($value) ? (string) $value : ''), '/').'.*',
+            Method::EndsWith => '.*'.preg_quote(\is_string($value) ? $value : (\is_scalar($value) ? (string) $value : ''), '/'),
+            default => $value,
+        };
     }
 
     /**
-     * Does the adapter require booleans to be converted to integers (0/1)?
+     * Get Mongo Order
      *
-     * @return bool
-     */
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Does the adapter includes boundary during spatial contains?
      *
-     * @return bool
+     * @throws Exception
      */
-
-    public function getSupportForBoundaryInclusiveContains(): bool
+    protected function getOrder(OrderDirection $order): int
     {
-        return false;
+        return match ($order) {
+            OrderDirection::Asc => 1,
+            OrderDirection::Desc => -1,
+            default => throw new DatabaseException('Unknown sort order:'.$order->value.'. Must be one of '.OrderDirection::Asc->value.', '.OrderDirection::Desc->value),
+        };
     }
 
     /**
-     * Does the adapter support order attribute in spatial indexes?
+     * Check if tenant should be added to index
      *
-     * @return bool
+     * @param  Document|string  $indexOrType  Index document or index type string
      */
-    public function getSupportForSpatialIndexOrder(): bool
+    protected function shouldAddTenantToIndex(Index|Document|string|IndexType $indexOrType): bool
     {
-        return false;
-    }
+        if (! $this->sharedTables) {
+            return false;
+        }
 
+        if ($indexOrType instanceof Index) {
+            $indexType = $indexOrType->type;
+        } elseif ($indexOrType instanceof Document) {
+            $rawIndexType = $indexOrType->getAttribute('type');
+            $indexTypeVal = \is_string($rawIndexType) ? $rawIndexType : (\is_scalar($rawIndexType) ? (string) $rawIndexType : '');
+            $indexType = IndexType::tryFrom($indexTypeVal) ?? IndexType::Key;
+        } elseif ($indexOrType instanceof IndexType) {
+            $indexType = $indexOrType;
+        } else {
+            $indexType = IndexType::tryFrom($indexOrType) ?? IndexType::Key;
+        }
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
+        return $indexType !== IndexType::Ttl;
     }
 
     /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
-     *
-     * @return bool
+     * @param  array<string>  $selections
      */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
+    protected function getAttributeProjection(array $selections, string $prefix = ''): mixed
     {
-        return false;
-    }
+        $projection = [];
 
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
-    }
+        $internalKeys = \array_map(
+            fn (Attribute $attr) => $attr->key,
+            Database::internalAttributes()
+        );
 
-    /**
-     * Does the adapter support multiple fulltext indexes?
-     *
-     * @return bool
-     */
-    public function getSupportForMultipleFulltextIndexes(): bool
-    {
-        return false;
-    }
+        foreach ($selections as $selection) {
+            // Skip internal attributes since all are selected by default
+            if (\in_array($selection, $internalKeys)) {
+                continue;
+            }
 
-    /**
-     * Does the adapter support identical indexes?
-     *
-     * @return bool
-     */
-    public function getSupportForIdenticalIndexes(): bool
-    {
-        return false;
-    }
+            $projection[$selection] = 1;
+        }
 
-    /**
-     * Does the adapter support random order for queries?
-     *
-     * @return bool
-     */
-    public function getSupportForOrderRandom(): bool
-    {
-        return false;
-    }
+        $projection[Storage::UID] = 1;
+        $projection[Storage::SEQUENCE] = 1;
+        $projection[Storage::CREATED_AT] = 1;
+        $projection[Storage::UPDATED_AT] = 1;
+        $projection[Storage::PERMISSIONS] = 1;
 
-    public function getSupportForVectors(): bool
-    {
-        return false;
+        return $projection;
     }
 
     /**
      * Flattens the array.
      *
-     * @param mixed $list
      * @return array<mixed>
      */
     protected function flattenArray(mixed $list): array
     {
-        if (!is_array($list)) {
+        if (! is_array($list)) {
             // make sure the input is an array
-            return array($list);
+            return [$list];
         }
 
         $newArray = [];
@@ -3989,7 +3755,7 @@ protected function flattenArray(mixed $list): array
     }
 
     /**
-     * @param array<string, mixed>|Document $target
+     * @param  array<string, mixed>|Document  $target
      * @return array<string, mixed>
      */
     protected function removeNullKeys(array|Document $target): array
@@ -4005,16 +3771,10 @@ protected function removeNullKeys(array|Document $target): array
             $cleaned[$key] = $value;
         }
 
-
         return $cleaned;
     }
 
-    public function getKeywords(): array
-    {
-        return [];
-    }
-
-    protected function processException(\Throwable $e): \Throwable
+    protected function processException(Throwable $e): Throwable
     {
         // Timeout
         if ($e->getCode() === 50 || $e->getCode() === 262) {
@@ -4024,9 +3784,10 @@ protected function processException(\Throwable $e): \Throwable
         // Duplicate key error
         if ($e->getCode() === 11000 || $e->getCode() === 11001) {
             $index = $this->getViolatedIndex($e->getMessage());
-            if ($index !== null && $index !== '_uid' && $index !== '_id_') {
+            if ($index !== null && $index !== Storage::UID && $index !== '_id_') {
                 return new UniqueException('Unique index violation', $e->getCode(), $e);
             }
+
             return new DuplicateException('Document already exists', $e->getCode(), $e);
         }
 
@@ -4040,208 +3801,45 @@ protected function processException(\Throwable $e): \Throwable
             return new DuplicateException('Index already exists', $e->getCode(), $e);
         }
 
-        // No transaction
-        if ($e->getCode() === 251) {
-            return new TransactionException('No active transaction', $e->getCode(), $e);
-        }
-
-        // Aborted transaction
-        if ($e->getCode() === 112) {
-            return new TransactionException('Transaction aborted', $e->getCode(), $e);
-        }
-
-        // Invalid operation (MongoDB error code 14)
-        if ($e->getCode() === 14) {
-            return new TypeException('Invalid operation', $e->getCode(), $e);
-        }
-
-        // Invalid $pow argument (0 raised to a negative power) — matches the SQL adapters, which
-        // report an undefined power as a numeric range error.
-        if ($e->getCode() === 28764) {
-            return new LimitException('Value out of range', $e->getCode(), $e);
-        }
-
-        return $e;
-    }
-
-    /**
-     * Extract the index name from a duplicate key error, e.g.
-     * "E11000 duplicate key error collection: db.movies index: _uid dup key: { _uid: \"movie\" }"
-     * resolves to "_uid". Returns null when the message cannot be parsed.
-     */
-    protected function getViolatedIndex(string $message): ?string
-    {
-        if (\preg_match('/index:\s*(\S+)\s+dup key/', $message, $matches) !== 1) {
-            return null;
-        }
-
-        return $matches[1];
-    }
-
-    protected function quote(string $string): string
-    {
-        return "";
-    }
-
-    /**
-     * @param mixed $stmt
-     * @return bool
-     */
-    protected function execute(mixed $stmt): bool
-    {
-        return true;
-    }
-
-    /**
-     * @return string
-     */
-    public function getIdAttributeType(): string
-    {
-        return Database::VAR_UUID7;
-    }
-
-    /**
-     * @return int
-     */
-    public function getMaxIndexLength(): int
-    {
-        return 1024;
-    }
-
-    /**
-     * @return int
-     */
-    public function getMaxUIDLength(): int
-    {
-        return 255;
-    }
-
-    public function getConnectionId(): string
-    {
-        return '0';
-    }
-
-    public function getInternalIndexesKeys(): array
-    {
-        return [];
-    }
-
-    public function getSchemaAttributes(string $collection): array
-    {
-        return [];
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSchemaIndexes(string $collection): array
-    {
-        return [];
-    }
-
-    /**
-     * @param string $collection
-     * @param array<int|string> $tenants
-     * @return int|string|null|array<string, array<int|string|null>>
-     */
-    public function getTenantFilters(
-        string $collection,
-        array $tenants = [],
-    ): int|string|null|array {
-        $values = [];
-        if (!$this->sharedTables) {
-            return $values;
-        }
-
-        if (\count($tenants) === 0) {
-            $values[] = $this->getTenant();
-        } else {
-            for ($index = 0; $index < \count($tenants); $index++) {
-                $values[] = $tenants[$index];
-            }
-        }
-
-        if ($collection === Database::METADATA) {
-            $values[] = null;
-        }
-
-        if (\count($values) === 1) {
-            return $values[0];
-        }
-
-
-        return ['$in' => $values];
-    }
-
-    public function decodePoint(string $wkb): array
-    {
-        return [];
-    }
-
-    /**
-     * Decode a WKB or textual LINESTRING into [[x1, y1], [x2, y2], ...]
-     *
-     * @param string $wkb
-     * @return float[][] Array of points, each as [x, y]
-     */
-    public function decodeLinestring(string $wkb): array
-    {
-        return [];
-    }
-
-    /**
-     * Decode a WKB or textual POLYGON into [[[x1, y1], [x2, y2], ...], ...]
-     *
-     * @param string $wkb
-     * @return float[][][] Array of rings, each ring is an array of points [x, y]
-     */
-    public function decodePolygon(string $wkb): array
-    {
-        return [];
-    }
+        // No transaction
+        if ($e->getCode() === 251) {
+            return new TransactionException('No active transaction', $e->getCode(), $e);
+        }
 
-    /**
-     * Get the query to check for tenant when in shared tables mode
-     *
-     * @param string $collection The collection being queried
-     * @param string $alias The alias of the parent collection if in a subquery
-     * @return string
-     */
-    public function getTenantQuery(string $collection, string $alias = ''): string
-    {
-        return '';
-    }
+        // Aborted transaction
+        if ($e->getCode() === 112) {
+            return new TransactionException('Transaction aborted', $e->getCode(), $e);
+        }
 
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
-    }
+        // Invalid operation (MongoDB error code 14)
+        if ($e->getCode() === 14) {
+            return new TypeException('Invalid operation', $e->getCode(), $e);
+        }
 
-    public function getSupportNonUtfCharacters(): bool
-    {
-        return false;
-    }
+        if ($e->getCode() === 28764) {
+            return new LimitException('Value out of range', $e->getCode(), $e);
+        }
 
-    public function getSupportForTrigramIndex(): bool
-    {
-        return false;
+        return $e;
     }
 
-    public function getSupportForTTLIndexes(): bool
+    protected function getViolatedIndex(string $message): ?string
     {
-        return true;
+        if (\preg_match('/index:\s*(\S+)\s+dup key/', $message, $matches) !== 1) {
+            return null;
+        }
+
+        return $matches[1];
     }
 
-    public function getSupportForTransactionRetries(): bool
+    protected function quote(string $string): string
     {
-        return false;
+        return '';
     }
 
-    public function getSupportForNestedTransactions(): bool
+    protected function execute(mixed $stmt): bool
     {
-        return false;
+        return true;
     }
 
     protected function isExtendedISODatetime(string $val): bool
@@ -4255,7 +3853,6 @@ protected function isExtendedISODatetime(string $val): bool
          *   YYYY-MM-DDTHH:mm:ss.fffffZ       (26)
          *   YYYY-MM-DDTHH:mm:ss.fffff+HH:MM  (31)
          */
-
         $len = strlen($val);
 
         // absolute minimum
@@ -4265,9 +3862,9 @@ protected function isExtendedISODatetime(string $val): bool
 
         // fixed datetime fingerprints
         if (
-            !isset($val[19]) ||
-            $val[4]  !== '-' ||
-            $val[7]  !== '-' ||
+            ! isset($val[19]) ||
+            $val[4] !== '-' ||
+            $val[7] !== '-' ||
             $val[10] !== 'T' ||
             $val[13] !== ':' ||
             $val[16] !== ':'
@@ -4284,7 +3881,7 @@ protected function isExtendedISODatetime(string $val): bool
             $val[$len - 3] === ':'
         );
 
-        if (!$hasZ && !$hasOffset) {
+        if (! $hasZ && ! $hasOffset) {
             return false;
         }
 
@@ -4297,12 +3894,12 @@ protected function isExtendedISODatetime(string $val): bool
         }
 
         $digitPositions = [
-            0,1,2,3,
-            5,6,
-            8,9,
-            11,12,
-            14,15,
-            17,18
+            0, 1, 2, 3,
+            5, 6,
+            8, 9,
+            11, 12,
+            14, 15,
+            17, 18,
         ];
 
         $timeEnd = $hasZ ? $len - 1 : $len - 6;
@@ -4325,7 +3922,7 @@ protected function isExtendedISODatetime(string $val): bool
         }
 
         foreach ($digitPositions as $i) {
-            if (!ctype_digit($val[$i])) {
+            if (! ctype_digit($val[$i])) {
                 return false;
             }
         }
@@ -4342,24 +3939,306 @@ protected function convertUTCDateToString(mixed $node): mixed
             // Handle Extended JSON format from (array) cast
             // Format: {"$date":{"$numberLong":"1760405478290"}}
             if (is_array($node['$date']) && isset($node['$date']['$numberLong'])) {
-                $milliseconds = (int)$node['$date']['$numberLong'];
+                /** @var mixed $numberLongVal */
+                $numberLongVal = $node['$date']['$numberLong'];
+                $milliseconds = \is_int($numberLongVal) ? $numberLongVal : (\is_numeric($numberLongVal) ? (int) $numberLongVal : 0);
                 $seconds = intdiv($milliseconds, 1000);
                 $microseconds = ($milliseconds % 1000) * 1000;
-                $dateTime = \DateTime::createFromFormat('U.u', $seconds . '.' . str_pad((string)$microseconds, 6, '0'));
+                $dateTime = NativeDateTime::createFromFormat('U.u', $seconds.'.'.str_pad((string) $microseconds, 6, '0'));
                 if ($dateTime) {
-                    $dateTime->setTimezone(new \DateTimeZone('UTC'));
+                    $dateTime->setTimezone(new DateTimeZone('UTC'));
                     $node = DateTime::format($dateTime);
                 }
             }
         } elseif (is_string($node)) {
             // Already a string, validate and pass through
             try {
-                new \DateTime($node);
-            } catch (\Exception $e) {
+                new NativeDateTime($node);
+            } catch (Exception $e) {
                 // Invalid date string, skip
             }
         }
 
         return $node;
     }
+
+    /**
+     * Helper to add transaction/session context to command options if in transaction
+     * Includes defensive check to ensure session is valid
+     *
+     * @param  array<string, mixed>  $options
+     * @return array<string, mixed>
+     */
+    private function getTransactionOptions(array $options = []): array
+    {
+        if ($this->inTransaction > 0 && $this->session !== null) {
+            // Pass the session array directly - the client will handle the transaction state internally
+            $options['session'] = $this->session;
+        }
+
+        return $options;
+    }
+
+    /**
+     * Create a safe MongoDB regex pattern by escaping special characters
+     *
+     * @param  string  $value  The user input to escape
+     * @param  string  $pattern  The pattern template (e.g., ".*%s.*" for contains)
+     *
+     * @throws DatabaseException
+     */
+    private function createSafeRegex(string $value, string $pattern = '%s', string $flags = 'i'): Regex
+    {
+        $escaped = preg_quote($value, '/');
+
+        // Validate that the pattern doesn't contain injection vectors
+        if (preg_match('/\$[a-z]+/i', $escaped)) {
+            throw new DatabaseException('Invalid regex pattern: potential injection detected');
+        }
+
+        $finalPattern = sprintf($pattern, $escaped);
+
+        return new Regex($finalPattern, $flags);
+    }
+
+    /**
+     * @param  array<string, mixed>  $document
+     * @param  array<string, mixed>  $options
+     * @return array<string, mixed>
+     *
+     * @throws DuplicateException
+     * @throws Exception
+     */
+    private function insertDocument(string $name, array $document, array $options = []): array
+    {
+        try {
+            $this->client->insert($name, $document, $options);
+            $filters = [Storage::UID => $document[Storage::UID]];
+
+            try {
+                $findResult = $this->client->find(
+                    $name,
+                    $filters,
+                    array_merge(['limit' => 1], $options)
+                );
+                /** @var \stdClass $findResultCursor */
+                $findResultCursor = $findResult->cursor;
+                /** @var array<mixed> $firstBatch */
+                $firstBatch = $findResultCursor->firstBatch;
+                $result = $firstBatch[0];
+            } catch (MongoException $e) {
+                throw $this->processException($e);
+            }
+
+            /** @var array<string, mixed> $toArrayResult */
+            $toArrayResult = $this->client->toArray($result) ?? [];
+            return $toArrayResult;
+        } catch (MongoException $e) {
+            throw $this->processException($e);
+        }
+    }
+
+    /**
+     * Converts Appwrite database type to MongoDB BSON type code.
+     */
+    private function getMongoTypeCode(ColumnType $type): string
+    {
+        return match ($type) {
+            ColumnType::String,
+            ColumnType::Varchar,
+            ColumnType::Text,
+            ColumnType::MediumText,
+            ColumnType::LongText,
+            ColumnType::Id,
+            ColumnType::Uuid7 => 'string',
+            ColumnType::BigInteger,
+            ColumnType::BigSerial => 'long',
+            ColumnType::Integer => 'int',
+            ColumnType::Float,
+            ColumnType::Double => 'double',
+            ColumnType::Boolean => 'bool',
+            ColumnType::Datetime => 'date',
+            default => 'string'
+        };
+    }
+
+    /**
+     * Converts timestamp to Mongo\BSON datetime format.
+     *
+     * @throws Exception
+     */
+    private function toMongoDatetime(string $dt): UTCDateTime
+    {
+        return new UTCDateTime(new NativeDateTime($dt));
+    }
+
+    /**
+     * Recursive function to replace chars in array keys, while
+     * skipping any that are explicitly excluded.
+     *
+     * @param  array<string, mixed>  $array
+     * @param  array<string>  $exclude
+     * @return array<string, mixed>
+     */
+    private function replaceInternalIdsKeys(array $array, string $from, string $to, array $exclude = []): array
+    {
+        $result = [];
+
+        foreach ($array as $key => $value) {
+            if (! in_array($key, $exclude)) {
+                $key = str_replace($from, $to, $key);
+            }
+
+            if (is_array($value)) {
+                /** @var array<string, mixed> $value */
+                $result[$key] = $this->replaceInternalIdsKeys($value, $from, $to, $exclude);
+            } else {
+                $result[$key] = $value;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param  array<string, mixed>  $filter
+     */
+    private function handleObjectFilters(Query $query, array &$filter): void
+    {
+        $conditions = [];
+        $isNot = in_array($query->getMethod(), [Method::NotContains, Method::NotEqual]);
+        $values = $query->getValues();
+        foreach ($values as $attribute => $value) {
+            $flattendQuery = $this->flattenWithDotNotation(is_string($attribute) ? $attribute : '', $value);
+            $flattenedObjectKey = array_key_first($flattendQuery);
+            if ($flattenedObjectKey === null) {
+                continue;
+            }
+            $queryValue = $flattendQuery[$flattenedObjectKey];
+            $queryAttribute = $query->getAttribute();
+            $flattenedQueryField = array_key_first($flattendQuery);
+            $flattenedObjectKey = $flattenedQueryField === '' ? $queryAttribute : $queryAttribute.'.'.array_key_first($flattendQuery);
+            switch ($query->getMethod()) {
+
+                case Method::Contains:
+                case Method::ContainsAny:
+                case Method::ContainsAll:
+                case Method::NotContains:
+                    $arrayValue = \is_array($queryValue) ? $queryValue : [$queryValue];
+                    $operator = $isNot ? '$nin' : '$in';
+                    $conditions[] = [$flattenedObjectKey => [$operator => $arrayValue]];
+                    break;
+
+                case Method::Equal:
+                case Method::NotEqual:
+                    if (\is_array($queryValue)) {
+                        $operator = $isNot ? '$nin' : '$in';
+                        $conditions[] = [$flattenedObjectKey => [$operator => $queryValue]];
+                    } else {
+                        $operator = $isNot ? '$ne' : '$eq';
+                        $conditions[] = [$flattenedObjectKey => [$operator => $queryValue]];
+                    }
+
+                    break;
+
+            }
+        }
+
+        $logicalOperator = $isNot ? '$and' : '$or';
+        if (count($conditions) && isset($filter[$logicalOperator])) {
+            $existingLogical = $filter[$logicalOperator];
+            /** @var array<mixed> $existingLogicalArr */
+            $existingLogicalArr = \is_array($existingLogical) ? $existingLogical : [];
+            $filter[$logicalOperator] = array_merge($existingLogicalArr, $conditions);
+        } else {
+            $filter[$logicalOperator] = $conditions;
+        }
+    }
+
+    /**
+     * Flatten a nested associative array into Mongo-style dot notation.
+     *
+     * @return array<string, mixed>
+     */
+    private function flattenWithDotNotation(string $key, mixed $value, string $prefix = ''): array
+    {
+        /** @var array<string, mixed> $result */
+        $result = [];
+
+        /** @var array<array{0: string, 1: mixed}> $stack */
+        $stack = [];
+
+        $initialKey = $prefix === '' ? $key : $prefix.'.'.$key;
+        $stack[] = [$initialKey, $value];
+        while (! empty($stack)) {
+            $item = array_pop($stack);
+            /** @var array{0: string, 1: mixed} $item */
+            [$currentPath, $currentValue] = $item;
+            if (is_array($currentValue) && ! array_is_list($currentValue)) {
+                foreach ($currentValue as $nextKey => $nextValue) {
+                    $nextKeyStr = (string) $nextKey;
+                    $nextPath = $currentPath === '' ? $nextKeyStr : $currentPath.'.'.$nextKeyStr;
+                    $stack[] = [$nextPath, $nextValue];
+                }
+            } else {
+                // leaf node
+                $result[$currentPath] = $currentValue;
+            }
+        }
+
+        return $result;
+    }
+
+    private function convertStdClassToArray(mixed $value): mixed
+    {
+        if (is_object($value) && get_class($value) === stdClass::class) {
+            $properties = get_object_vars($value);
+
+            return $properties === [] ? $value : array_map($this->convertStdClassToArray(...), $properties);
+        }
+
+        if (is_array($value)) {
+            return array_map(
+                fn ($v) => $this->convertStdClassToArray($v),
+                $value
+            );
+        }
+
+        return $value;
+    }
+
+    /**
+     * Get fields to unset for schemaless upsert operations
+     *
+     * @param  array<string, mixed>  $record
+     * @return array<string, string>
+     */
+    private function getUpsertAttributeRemovals(Document $oldDocument, Document $newDocument, array $record): array
+    {
+        $unsetFields = [];
+
+        if ($this->supports(Capability::DefinedAttributes) || $oldDocument->isEmpty()) {
+            return $unsetFields;
+        }
+
+        $oldUserAttributes = $oldDocument->getAttributes();
+        $newUserAttributes = $newDocument->getAttributes();
+
+        $protectedFields = [Storage::UID, Storage::SEQUENCE, Storage::CREATED_AT, Storage::UPDATED_AT, Storage::PERMISSIONS, Storage::TENANT, Storage::VERSION];
+
+        foreach ($oldUserAttributes as $originalKey => $originalValue) {
+            if (in_array($originalKey, $protectedFields) || array_key_exists($originalKey, $newUserAttributes)) {
+                continue;
+            }
+
+            $transformed = $this->replaceChars('$', '_', [$originalKey => $originalValue]);
+            $dbKey = array_key_first($transformed);
+
+            if ($dbKey && ! array_key_exists($dbKey, $record) && ! in_array($dbKey, $protectedFields)) {
+                $unsetFields[$dbKey] = '';
+            }
+        }
+
+        return $unsetFields;
+    }
 }
diff --git a/src/Database/Adapter/MySQL.php b/src/Database/Adapter/MySQL.php
index 6a43047957..76ec7f89b0 100644
--- a/src/Database/Adapter/MySQL.php
+++ b/src/Database/Adapter/MySQL.php
@@ -2,81 +2,161 @@
 
 namespace Utopia\Database\Adapter;
 
+use Exception;
 use PDOException;
+use PDOStatement;
+use Swoole\Database\PDOStatementProxy;
+use Throwable;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Character as CharacterException;
 use Utopia\Database\Exception\Dependency as DependencyException;
 use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
 use Utopia\Database\Query;
-
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\MySQL as MySQLBuilder;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Database adapter for MySQL, extending MariaDB with MySQL-specific behavior and overrides.
+ */
 class MySQL extends MariaDB
 {
+    /**
+     * Get the list of capabilities supported by the MySQL adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        $remove = [
+            Capability::BoundaryInclusive,
+            Capability::SpatialIndexOrder,
+            Capability::OptionalSpatial,
+        ];
+
+        return array_values(array_filter(
+            array_merge(parent::capabilities(), [
+                Capability::SpatialAxisOrder,
+                Capability::MultiDimensionDistance,
+                Capability::CastIndexArray,
+            ]),
+            fn (Capability $c) => ! in_array($c, $remove, true)
+        ));
+    }
+
     /**
      * Set max execution time
-     * @param int $milliseconds
-     * @param string $event
-     * @return void
+     *
      * @throws DatabaseException
      */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
-        if (!$this->getSupportForTimeouts()) {
-            return;
-        }
         if ($milliseconds <= 0) {
             throw new DatabaseException('Timeout must be greater than 0');
         }
 
-        $this->timeout = $milliseconds;
+        if ($event === Event::All) {
+            $this->applyTimeout($milliseconds);
+        }
+
+        $this->setTimeoutState($milliseconds, $event);
+    }
+
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        if ($event === Event::All) {
+            $this->applyTimeout(0);
+        }
+
+        $this->clearTimeoutState($event);
+    }
+
+    private int $appliedMaxExecutionTime = 0;
+
+    /**
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
+     */
+    protected function execute(mixed $stmt, ?Event $event = null): bool
+    {
+        $event ??= $this->getStatementEvent($stmt);
+        $baseline = $this->getTimeout();
+        $timeout = $event === null ? $baseline : $this->getTimeout($event);
+        $this->applyTimeout($timeout);
+
+        $exception = null;
+        try {
+            return $stmt->execute();
+        } catch (Throwable $error) {
+            $exception = $error;
+            throw $error;
+        } finally {
+            if ($timeout !== $baseline) {
+                try {
+                    $this->applyTimeout($baseline);
+                } catch (Throwable $error) {
+                    if ($exception === null) {
+                        throw $error;
+                    }
+                }
+            }
+        }
+    }
+
+    private function applyTimeout(int $milliseconds): void
+    {
+        if ($milliseconds === $this->appliedMaxExecutionTime) {
+            return;
+        }
 
-        $this->before($event, 'timeout', function ($sql) use ($milliseconds) {
-            return \preg_replace(
-                pattern: '/SELECT/',
-                replacement: "SELECT /*+ max_execution_time({$milliseconds}) */",
-                subject: $sql,
-                limit: 1
-            );
-        });
+        $this->getPDO()->exec("SET SESSION MAX_EXECUTION_TIME = {$milliseconds}");
+        $this->appliedMaxExecutionTime = $milliseconds;
     }
 
     /**
      * Get size of collection on disk
-     * @param string $collection
-     * @return int
+     *
      * @throws DatabaseException
      */
     public function getSizeOfCollectionOnDisk(string $collection): int
     {
         $collection = $this->filter($collection);
-        $collection = $this->getNamespace() . '_' . $collection;
+        $collection = $this->getNamespace().'_'.$collection;
         $database = $this->getDatabase();
-        $name = $database . '/' . $collection;
-        $permissions = $database . '/' . $collection . '_perms';
+        $name = $database.'/'.$collection;
+        $permissions = $database.'/'.Storage::permissionsTable($collection);
 
-        $collectionSize = $this->getPDO()->prepare("
+        $collectionSize = $this->prepareStatement('
              SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
              FROM INFORMATION_SCHEMA.INNODB_TABLESPACES
              WHERE NAME = :name
-        ");
+        ', Event::CollectionRead);
 
-        $permissionsSize = $this->getPDO()->prepare("
+        $permissionsSize = $this->prepareStatement('
              SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
              FROM INFORMATION_SCHEMA.INNODB_TABLESPACES
              WHERE NAME = :permissions
-        ");
+        ', Event::CollectionRead);
 
         $collectionSize->bindParam(':name', $name);
         $permissionsSize->bindParam(':permissions', $permissions);
 
         try {
-            $collectionSize->execute();
-            $permissionsSize->execute();
-            $size = $collectionSize->fetchColumn() + $permissionsSize->fetchColumn();
+            $this->execute($collectionSize);
+            $this->execute($permissionsSize);
+            $collVal = $collectionSize->fetchColumn();
+            $permVal = $permissionsSize->fetchColumn();
+            $size = (int)(\is_numeric($collVal) ? $collVal : 0) + (int)(\is_numeric($permVal) ? $permVal : 0);
         } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
         }
 
         return $size;
@@ -85,68 +165,40 @@ public function getSizeOfCollectionOnDisk(string $collection): int
     /**
      * Handle distance spatial queries
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $type
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
-    */
+     * @param  array<string, mixed>  $binds
+     */
     protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
     {
+        /** @var array<mixed> $distanceParams */
         $distanceParams = $query->getValues()[0];
-        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($distanceParams[0]);
+        $geomArray = \is_array($distanceParams[0]) ? $distanceParams[0] : [];
+        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($geomArray);
         $binds[":{$placeholder}_1"] = $distanceParams[1];
 
         $useMeters = isset($distanceParams[2]) && $distanceParams[2] === true;
 
-        switch ($query->getMethod()) {
-            case Query::TYPE_DISTANCE_EQUAL:
-                $operator = '=';
-                break;
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-                $operator = '!=';
-                break;
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-                $operator = '>';
-                break;
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                $operator = '<';
-                break;
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
-        }
+        $operator = match ($query->getMethod()) {
+            Method::DistanceEqual => '=',
+            Method::DistanceNotEqual => '!=',
+            Method::DistanceGreaterThan => '>',
+            Method::DistanceLessThan => '<',
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
+        };
 
         if ($useMeters) {
-            $attr = "ST_SRID({$alias}.{$attribute}, " . Database::DEFAULT_SRID . ")";
+            $attr = "ST_SRID({$alias}.{$attribute}, ".Database::DEFAULT_SRID.')';
             $geom = $this->getSpatialGeomFromText(":{$placeholder}_0", null);
+
             return "ST_Distance({$attr}, {$geom}, 'metre') {$operator} :{$placeholder}_1";
         }
         // need to use srid 0 because of geometric distance
-        $attr = "ST_SRID({$alias}.{$attribute}, " . 0 . ")";
+        $attr = "ST_SRID({$alias}.{$attribute}, ". 0 .')';
         $geom = $this->getSpatialGeomFromText(":{$placeholder}_0", 0);
-        return "ST_Distance({$attr}, {$geom}) {$operator} :{$placeholder}_1";
-    }
-
-    public function getSupportForIndexArray(): bool
-    {
-        /**
-         * @link https://bugs.mysql.com/bug.php?id=111037
-         */
-        return true;
-    }
-
-    public function getSupportForCastIndexArray(): bool
-    {
-        if (!$this->getSupportForIndexArray()) {
-            return false;
-        }
 
-        return true;
+        return "ST_Distance({$attr}, {$geom}) {$operator} :{$placeholder}_1";
     }
 
-    protected function processException(PDOException $e): \Exception
+    protected function processException(PDOException $e): Exception
     {
         if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1366) {
             return new CharacterException('Invalid character', $e->getCode(), $e);
@@ -173,139 +225,95 @@ protected function processException(PDOException $e): \Exception
 
         return parent::processException($e);
     }
-    /**
-     * Does the adapter includes boundary during spatial contains?
-     *
-     * @return bool
-     */
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return false;
-    }
-    /**
-     * Does the adapter support order attribute in spatial indexes?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialIndexOrder(): bool
+
+    protected function createBuilder(): SQLBuilder
     {
-        return false;
+        return new MySQLBuilder();
     }
 
     /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
+     * Get the MySQL SQL type definition for spatial column types with SRID support.
      *
-     * @return bool
+     * @param string $type The spatial type (point, linestring, polygon)
+     * @param bool $required Whether the column is NOT NULL
+     * @return string
      */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Spatial type attribute
-    */
     public function getSpatialSQLType(string $type, bool $required): string
     {
         switch ($type) {
-            case Database::VAR_POINT:
+            case ColumnType::Point->value:
                 $type = 'POINT SRID 4326';
-                if (!$this->getSupportForSpatialIndexNull()) {
+                if (! $this->supports(Capability::SpatialIndexNull)) {
                     if ($required) {
                         $type .= ' NOT NULL';
                     } else {
                         $type .= ' NULL';
                     }
                 }
+
                 return $type;
 
-            case Database::VAR_LINESTRING:
+            case ColumnType::Linestring->value:
                 $type = 'LINESTRING SRID 4326';
-                if (!$this->getSupportForSpatialIndexNull()) {
+                if (! $this->supports(Capability::SpatialIndexNull)) {
                     if ($required) {
                         $type .= ' NOT NULL';
                     } else {
                         $type .= ' NULL';
                     }
                 }
-                return $type;
 
+                return $type;
 
-            case Database::VAR_POLYGON:
+            case ColumnType::Polygon->value:
                 $type = 'POLYGON SRID 4326';
-                if (!$this->getSupportForSpatialIndexNull()) {
+                if (! $this->supports(Capability::SpatialIndexNull)) {
                     if ($required) {
                         $type .= ' NOT NULL';
                     } else {
                         $type .= ' NULL';
                     }
                 }
+
                 return $type;
         }
-        return '';
-    }
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
+        return '';
     }
 
     /**
      * Get the spatial axis order specification string for MySQL
      * MySQL with SRID 4326 expects lat-long by default, but our data is in long-lat format
-     *
-     * @return string
      */
     protected function getSpatialAxisOrderSpec(): string
     {
         return "'axis-order=long-lat'";
     }
 
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
-     */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
-    }
-
     /**
      * Get SQL expression for operator
      * Override for MySQL-specific operator implementations
-     *
-     * @param string $column
-     * @param \Utopia\Database\Operator $operator
-     * @param array<string, mixed> $binds
-     * @return ?string
      */
-    protected function getOperatorSQL(string $column, \Utopia\Database\Operator $operator, array &$binds): ?string
+    protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
         $quotedColumn = $this->quote($column);
         $method = $operator->getMethod();
         $values = $operator->getValues();
 
         switch ($method) {
-            case Operator::TYPE_ARRAY_APPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayAppend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(IFNULL({$quotedColumn}, JSON_ARRAY()), :$bindKey)";
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayPrepend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(:$bindKey, IFNULL({$quotedColumn}, JSON_ARRAY()))";
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 return "{$quotedColumn} = IFNULL((
                     SELECT JSON_ARRAYAGG(value)
                     FROM (
@@ -316,11 +324,6 @@ protected function getOperatorSQL(string $column, \Utopia\Database\Operator $ope
         }
 
         // For all other operators, use parent implementation
-        return parent::getOperatorSQL($column, $operator, $binds);
-    }
-
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
+        return parent::getOperatorSQL($column, $operator, $bindIndex);
     }
 }
diff --git a/src/Database/Adapter/Pool.php b/src/Database/Adapter/Pool.php
index 511da2b13a..556555e8ae 100644
--- a/src/Database/Adapter/Pool.php
+++ b/src/Database/Adapter/Pool.php
@@ -2,13 +2,30 @@
 
 namespace Utopia\Database\Adapter;
 
+use DateTime;
+use Throwable;
 use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Change;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Index;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Relationship;
 use Utopia\Database\Validator\Authorization;
 use Utopia\Pools\Pool as UtopiaPool;
-
+use Utopia\Query\CursorDirection;
+
+/**
+ * Connection pool adapter that delegates database operations to pooled adapter instances.
+ *
+ * Pool is a proxy: optional Feature methods are forwarded to the borrowed adapter.
+ * Feature support is reported by hasFeature(), not instanceof.
+ */
 class Pool extends Adapter
 {
     /**
@@ -23,23 +40,7 @@ class Pool extends Adapter
     protected ?Adapter $pinnedAdapter = null;
 
     /**
-     * The timeout each event is under, held here rather than on a connection.
-     *
-     * A timeout is adapter state, not a statement: every concrete adapter
-     * records it and applies it to the SQL it builds afterwards, and none of
-     * them contacts the server to set it. Delegating the call therefore opened
-     * a connection for the sole purpose of writing a number onto whichever one
-     * answered, which the pool took back moments later - so the timeout bound
-     * one connection and none of its siblings, and merely building a handle
-     * failed outright while the backing was unreachable, reporting a database
-     * as down to a caller that had not yet issued a query.
-     *
-     * @var array<string, int>
-     */
-    private array $timeouts = [];
-
-    /**
-     * @param UtopiaPool<covariant Adapter> $pool The pool to use for connections. Must contain instances of Adapter.
+     * @param  UtopiaPool<covariant Adapter>  $pool  The pool to use for connections. Must contain instances of Adapter.
      */
     public function __construct(UtopiaPool $pool)
     {
@@ -51,196 +52,293 @@ public function __construct(UtopiaPool $pool)
      *
      * Required because __call() can't be used to implement abstract methods.
      *
-     * @param string $method
-     * @param array<mixed> $args
-     * @return mixed
+     * @param  array<mixed>  $args
+     *
      * @throws DatabaseException
      */
     public function delegate(string $method, array $args): mixed
+    {
+        return $this->borrowAndInvoke($method, $args);
+    }
+
+    /**
+     * @param  class-string  $feature
+     * @param  array<mixed>  $args
+     */
+    protected function delegateFeature(string $feature, string $method, array $args): mixed
+    {
+        return $this->borrowAndInvoke($method, $args, $feature);
+    }
+
+    /**
+     * @param  array<mixed>  $args
+     * @param  class-string|null  $feature
+     */
+    protected function borrowAndInvoke(string $method, array $args, ?string $feature = null): mixed
     {
         if ($this->pinnedAdapter !== null) {
-            if ($this->skipDuplicates) {
-                return $this->pinnedAdapter->skipDuplicates(
-                    fn () => $this->pinnedAdapter->{$method}(...$args)
-                );
-            }
-            return $this->pinnedAdapter->{$method}(...$args);
+            $adapter = $this->pinnedAdapter;
+            $this->syncBorrowedAdapter($adapter);
+
+            return $this->invokeDelegated($adapter, $method, $args, $feature);
         }
 
-        return $this->pool->use(function (Adapter $adapter) use ($method, $args) {
-            // Run setters in case config changed since this connection was last used
-            $adapter->setDatabase($this->getDatabase());
-            $adapter->setNamespace($this->getNamespace());
-            $adapter->setSharedTables($this->getSharedTables());
-            $adapter->setTenant($this->getTenant());
-            $adapter->setAuthorization($this->authorization);
-
-            $this->syncTimeouts($adapter);
-            $adapter->resetDebug();
-            foreach ($this->getDebug() as $key => $value) {
-                $adapter->setDebug($key, $value);
-            }
-            $adapter->resetMetadata();
-            foreach ($this->getMetadata() as $key => $value) {
-                $adapter->setMetadata($key, $value);
-            }
+        return $this->pool->use(function (Adapter $adapter) use ($method, $args, $feature) {
+            $this->syncBorrowedAdapter($adapter);
 
-            if ($this->skipDuplicates) {
-                return $adapter->skipDuplicates(
-                    fn () => $adapter->{$method}(...$args)
-                );
-            }
-            return $adapter->{$method}(...$args);
+            return $this->invokeDelegated($adapter, $method, $args, $feature);
         });
     }
 
-    public function getDriver(): mixed
+    /**
+     * @param  array<mixed>  $args
+     * @param  class-string|null  $feature
+     */
+    protected function invokeDelegated(Adapter $adapter, string $method, array $args, ?string $feature = null): mixed
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
+        if ($feature !== null && ! $adapter instanceof $feature) {
+            throw new DatabaseException($this->unsupportedFeatureMessage($feature));
+        }
 
-    public function before(string $event, string $name = '', ?callable $callback = null): static
-    {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        if ($this->skipDuplicates) {
+            return $adapter->skipDuplicates(
+                fn () => $adapter->{$method}(...$args)
+            );
+        }
 
-        return $this;
+        return $adapter->{$method}(...$args);
     }
 
-    protected function trigger(string $event, mixed $query): mixed
+    /**
+     * @param  class-string  $feature
+     */
+    protected function unsupportedFeatureMessage(string $feature): string
+    {
+        return match ($feature) {
+            Feature\Upserts::class => 'Adapter does not support upserts',
+            Feature\RawQuery::class => 'Adapter does not support raw queries',
+            Feature\QueryBuilder::class => 'Adapter does not support query builder',
+            Feature\SchemaAttributes::class => 'Adapter does not support schema attributes',
+            Feature\SchemaIndexes::class => 'Adapter does not support schema indexes',
+            Feature\ColumnTypes::class => 'Adapter does not support column types',
+            Feature\Spatial::class => 'Adapter does not support spatial',
+            Feature\InternalCasting::class => 'Adapter does not support internal casting',
+            Feature\UTCCasting::class => 'Adapter does not support UTC casting',
+            Feature\ConnectionId::class => 'Adapter does not support connection id',
+            Feature\Relationships::class => 'Adapter does not support relationships',
+            Feature\Timeouts::class => 'Adapter does not support timeouts',
+            default => 'Adapter does not support '.$feature,
+        };
+    }
+
+    protected function syncBorrowedAdapter(Adapter $adapter): void
+    {
+        $adapter->setDatabase($this->getDatabase());
+        $adapter->setNamespace($this->getNamespace());
+        $adapter->setSharedTables($this->getSharedTables());
+        $adapter->setTenant($this->getTenant());
+        $adapter->setTenantPerDocument($this->getTenantPerDocument());
+        $adapter->setAuthorization($this->authorization);
+
+        $this->syncTimeouts($adapter);
+        $adapter->resetDebug();
+        foreach ($this->getDebug() as $key => $value) {
+            $adapter->setDebug($key, $value);
+        }
+        $adapter->resetMetadata();
+        foreach ($this->getMetadata() as $key => $value) {
+            $adapter->setMetadata($key, $value);
+        }
+        $adapter->setProfiler($this->profiler);
+        $adapter->resetTransforms();
+        foreach ($this->queryTransforms as $tName => $tTransform) {
+            $adapter->addTransform($tName, $tTransform);
+        }
+        $this->syncWriteHooks($adapter);
+    }
+
+    public function getDriver(): mixed
     {
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
     /**
-     * Zero is the value a caller's own default carries when it wants no
-     * timeout, so it clears the event rather than being refused. A connection
-     * is only ever asked for a timeout it can hold.
+     * Check if a specific capability is supported by the pooled adapter.
+     *
+     * @param Capability $feature The capability to check
+     * @return bool
      */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    public function supports(Capability $feature): bool
     {
-        if ($milliseconds <= 0) {
-            $this->clearTimeout($event);
-
-            return;
-        }
-
-        $this->timeouts[$event] = $milliseconds;
-        $this->timeout = $this->timeouts[Database::EVENT_ALL] ?? 0;
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
+    }
 
-        $this->syncPin();
+    /**
+     * Get all capabilities supported by the pooled adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        /** @var array<Capability> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     /**
-     * Clearing one event leaves the others alone. The concrete adapters keep a
-     * single timeout scalar that Postgres and Mongo apply to every statement,
-     * so a clear forwarded verbatim would drop the timeout the caller still
-     * has configured for everything else.
+     * @param  class-string  $feature
      */
-    public function clearTimeout(string $event): void
+    public function hasFeature(string $feature): bool
     {
-        unset($this->timeouts[$event]);
-        $this->timeout = $this->timeouts[Database::EVENT_ALL] ?? 0;
+        /** @var bool $result */
+        $result = $this->delegate('hasFeature', [$feature]);
 
-        $this->syncPin();
+        return $result;
     }
 
     /**
-     * The pool's own map is what a checkout replays, so a clear has to empty
-     * it. Inheriting the base implementation cleared almost nothing: it walks
-     * the events it finds in `$transformations`, and this adapter delegates
-     * `before()`, so its own array never holds more than `EVENT_ALL` however
-     * many events a caller has set a timeout for.
+     * Register a named query transform hook on the pooled adapter.
+     *
+     * @param string $name The transform name
+     * @param Transform $transform The transform instance
+     * @return static
      */
-    public function clearTimeouts(): void
+    public function addTransform(string $name, Transform $transform): static
     {
-        $this->timeouts = [];
-        $this->timeout = 0;
+        $this->queryTransforms[$name] = $transform;
 
-        $this->syncPin();
+        return $this;
     }
 
     /**
-     * The connection this caller's open transaction is pinned to, if any.
+     * Remove a named query transform hook from the pooled adapter.
      *
-     * A seam: a subclass that keys the pin by coroutine rather than by object
-     * overrides this, and the timeout setters reach the right connection
-     * without knowing how the pin is held.
+     * @param string $name The transform name to remove
+     * @return static
      */
-    protected function pin(): ?Adapter
+    public function removeTransform(string $name): static
     {
-        return $this->pinnedAdapter;
+        unset($this->queryTransforms[$name]);
+
+        return $this;
     }
 
     /**
-     * A timeout changed inside a transaction has to reach the connection
-     * running it. Every statement left in that transaction goes to the pinned
-     * connection, and it will not be checked out again before the commit, so
-     * waiting for the next checkout would leave the rest of the body running
-     * under the timeout the caller just replaced.
+     * Set the maximum execution time for queries on the pooled adapter.
+     *
+     * @param int $milliseconds Timeout in milliseconds
+     * @param Event $event The event scope for the timeout
+     * @return void
      */
-    private function syncPin(): void
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
-        $pinned = $this->pin();
+        // Zero is what a caller's own default carries when it wants no timeout,
+        // so it clears the event rather than pinning every statement to 0.
+        if ($milliseconds <= 0) {
+            $this->clearTimeout($event);
 
-        if ($pinned === null) {
             return;
         }
 
-        $this->syncTimeouts($pinned);
+        $this->setTimeoutState($milliseconds, $event);
+        $this->syncPinnedTimeouts();
+    }
+
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        $this->clearTimeoutState($event);
+        $this->syncPinnedTimeouts();
     }
 
     /**
-     * Put a connection into the timeout state this pool holds, as it is checked
-     * out. The connection outlives the handle that configured it and is handed
-     * on to handles that want a different timeout or none at all, so it is
-     * reset first: a handle carrying no timeout must not inherit one, and a
-     * handle carrying its own must not be left with an event the last holder
-     * set.
+     * A timeout is adapter state, not a statement: every concrete adapter records
+     * it and applies it to the SQL it builds afterwards, and none of them contacts
+     * the server to set it. Delegating the call therefore checked a connection out
+     * for the sole purpose of writing a number onto whichever one answered, so the
+     * timeout bound that connection and none of its siblings — and merely building
+     * a handle failed outright while the backing was unreachable, reporting a
+     * database as down to a caller that had not yet issued a query.
      *
-     * The global timeout is applied last, which decides what an engine with no
-     * per-event timeout does with one. MariaDB and MySQL hang a hook on the
-     * event and are unaffected; Postgres and Mongo take `$event` and discard
-     * it, so every call lands on the one scalar they bound every statement by
-     * and the last one wins. Applying the global last means a per-event
-     * refinement those two cannot express is ignored there. The other order
-     * would let a 5s read deadline silently bound every write on the handle,
-     * which is the failure worth avoiding.
+     * The state is replayed onto each connection as it is borrowed
+     * ({@see self::syncTimeouts()}), so the only connection that needs telling now
+     * is one already pinned: a transaction does not check out again before its
+     * commit, and the rest of its body must not run under the timeout the caller
+     * just replaced.
      */
-    protected function syncTimeouts(Adapter $adapter): void
+    private function syncPinnedTimeouts(): void
     {
-        $adapter->clearTimeouts();
-
-        foreach ($this->timeouts as $event => $milliseconds) {
-            if ($event === Database::EVENT_ALL) {
-                continue;
-            }
+        $pinned = $this->pin();
 
-            $adapter->setTimeout($milliseconds, $event);
+        if ($pinned !== null) {
+            $this->syncTimeouts($pinned);
         }
+    }
 
-        if (isset($this->timeouts[Database::EVENT_ALL])) {
-            $adapter->setTimeout($this->timeouts[Database::EVENT_ALL]);
-        }
+    /**
+     * Which connection this handle currently has pinned, if any. Read through a
+     * seam rather than off the property, because a handle that pins per
+     * coroutine keeps its pins somewhere else and would otherwise never be
+     * asked.
+     */
+    protected function pin(): ?Adapter
+    {
+        return $this->pinnedAdapter;
     }
 
+    /**
+     * Start a database transaction via the pooled adapter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException
+     */
     public function startTransaction(): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * Commit the current database transaction via the pooled adapter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException
+     */
     public function commitTransaction(): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * Roll back the current database transaction via the pooled adapter.
+     *
+     * @return bool
+     *
+     * @throws DatabaseException
+     */
     public function rollbackTransaction(): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
+    }
+
+    public function inTransaction(): bool
+    {
+        return $this->pinnedAdapter?->inTransaction() ?? parent::inTransaction();
     }
 
     public function getHostname(): string
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var string $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     /**
@@ -249,9 +347,11 @@ public function getHostname(): string
      * from running on different connections.
      *
      * @template T
-     * @param callable(): T $callback
+     *
+     * @param  callable(): T  $callback
      * @return T
-     * @throws \Throwable
+     *
+     * @throws Throwable
      */
     public function withTransaction(callable $callback): mixed
     {
@@ -262,21 +362,7 @@ public function withTransaction(callable $callback): mixed
         }
 
         return $this->pool->use(function (Adapter $adapter) use ($callback) {
-            $adapter->setDatabase($this->getDatabase());
-            $adapter->setNamespace($this->getNamespace());
-            $adapter->setSharedTables($this->getSharedTables());
-            $adapter->setTenant($this->getTenant());
-            $adapter->setAuthorization($this->authorization);
-
-            $this->syncTimeouts($adapter);
-            $adapter->resetDebug();
-            foreach ($this->getDebug() as $key => $value) {
-                $adapter->setDebug($key, $value);
-            }
-            $adapter->resetMetadata();
-            foreach ($this->getMetadata() as $key => $value) {
-                $adapter->setMetadata($key, $value);
-            }
+            $this->syncBorrowedAdapter($adapter);
 
             $this->pinnedAdapter = $adapter;
             try {
@@ -294,412 +380,560 @@ public function withTransaction(callable $callback): mixed
 
     protected function quote(string $string): string
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var string $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
+    }
+
+    protected function syncTimeouts(Adapter $adapter): void
+    {
+        if (! ($adapter instanceof Feature\Timeouts)) {
+            // Setting a timeout no longer checks a connection out, so this is the
+            // first moment the adapter's capabilities are known. Staying silent
+            // here would drop a bound the caller asked for and run the statement
+            // unbounded; the refusal belongs where the timeout would be applied,
+            // not where a handle is merely being built.
+            if ($this->timeouts !== []) {
+                throw new DatabaseException($this->unsupportedFeatureMessage(Feature\Timeouts::class));
+            }
+
+            return;
+        }
+
+        if (empty($this->timeouts)) {
+            $adapter->clearTimeout();
+
+            return;
+        }
+
+        if (count($this->timeouts) === 1 && isset($this->timeouts[Event::All->value])) {
+            $adapter->setTimeout($this->timeouts[Event::All->value]);
+
+            return;
+        }
+
+        // The concrete adapters keep one timeout scalar, which Postgres writes
+        // into SET statement_timeout and Mongo into maxTimeMS for every
+        // statement, so the last value applied is the one every statement runs
+        // under. Apply the per-event entries first and the global one last, or a
+        // per-event timeout set after the global one bounds everything.
+        $adapter->clearTimeout();
+        foreach ($this->timeouts as $event => $milliseconds) {
+            if ($event === Event::All->value) {
+                continue;
+            }
+
+            $adapter->setTimeout($milliseconds, Event::from($event));
+        }
+
+        if (isset($this->timeouts[Event::All->value])) {
+            $adapter->setTimeout($this->timeouts[Event::All->value]);
+        }
+    }
+
+    private function syncWriteHooks(Adapter $adapter): void
+    {
+        $current = $adapter->getWriteHooks();
+        if ($current === $this->writeHooks) {
+            return;
+        }
+
+        foreach ($current as $childHook) {
+            $adapter->removeWriteHook($childHook::class);
+        }
+
+        foreach ($this->writeHooks as $hook) {
+            $adapter->addWriteHook($hook);
+        }
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function ping(): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function reconnect(): void
     {
         $this->delegate(__FUNCTION__, \func_get_args());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function create(string $name): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function exists(string $database, ?string $collection = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function list(): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function delete(string $name): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function deleteCollection(string $id): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function analyzeCollection(string $collection): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function createAttributes(string $collection, array $attributes): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function deleteAttribute(string $collection, string $id): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function renameAttribute(string $collection, string $old, string $new): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function createRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay = false, string $id = '', string $twoWayKey = ''): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function createRelationship(Relationship $relationship): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegateFeature(Feature\Relationships::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function updateRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side, ?string $newKey = null, ?string $newTwoWayKey = null): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function updateRelationship(Relationship $relationship, ?string $newKey = null, ?string $newTwoWayKey = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegateFeature(Feature\Relationships::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function deleteRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function deleteRelationship(Relationship $relationship): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegateFeature(Feature\Relationships::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function renameIndex(string $collection, string $old, string $new): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function deleteIndex(string $collection, string $id): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function createDocument(Document $collection, Document $document): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function createDocuments(Document $collection, array $documents): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function updateDocuments(Document $collection, Document $updates, array $documents): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @param  array<Change>  $changes
+     * @return array<Document>
+     */
     public function upsertDocuments(Document $collection, string $attribute, array $changes): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegateFeature(Feature\Upserts::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function deleteDocument(string $collection, string $id): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array
+    /**
+     * {@inheritDoc}
+     */
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var float|int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function count(Document $collection, array $queries = [], ?int $max = null): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getSizeOfCollection(string $collection): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getSizeOfCollectionOnDisk(string $collection): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getLimitForString(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getLimitForInt(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getLimitForBigInt(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUnsignedBigInt(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getLimitForAttributes(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getLimitForIndexes(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getMaxIndexLength(): int
+    /**
+     * {@inheritDoc}
+     */
+    public function getMaxIndexLength(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getMaxVarcharLength(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getMaxUIDLength(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getMinDateTime(): \DateTime
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSchemas(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForAttributes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportForIndexArray(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForCastIndexArray(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUniqueIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForFulltextIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForPCRERegex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForPOSIXRegex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForTrigramIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForCasting(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForQueryContains(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForTimeouts(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForRelationships(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUpdateLock(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForBatchOperations(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForAttributeResizing(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForOperators(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForGetConnectionId(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUpserts(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForVectors(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForCaching(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForReconnection(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForHostname(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSpatialIndexNull(): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function getMinDateTime(): DateTime
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var DateTime $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getCountOfAttributes(Document $collection): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getCountOfIndexes(Document $collection): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getCountOfDefaultAttributes(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getCountOfDefaultIndexes(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getDocumentSizeLimit(): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getAttributeWidth(Document $collection): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getKeywords(): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<string> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     protected function getAttributeProjection(array $selections, string $prefix): mixed
@@ -707,184 +941,224 @@ protected function getAttributeProjection(array $selections, string $prefix): mi
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
-    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, float|int $value, string $updatedAt, float|int|null $min = null, float|int|null $max = null): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, float|int|string $value, string $updatedAt, float|int|string|null $min = null, float|int|string|null $max = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getConnectionId(): string
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var string $result */
+        $result = $this->delegateFeature(Feature\ConnectionId::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getInternalIndexesKeys(): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<string> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @return array<Document>
+     */
     public function getSchemaAttributes(string $collection): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegateFeature(Feature\SchemaAttributes::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @return array<Document>
+     */
     public function getSchemaIndexes(string $collection): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegateFeature(Feature\SchemaIndexes::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getTenantQuery(string $collection, string $alias = ''): string
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var string $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     protected function execute(mixed $stmt): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getIdAttributeType(): string
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var string $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getSequences(string $collection, array $documents): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForMultipleFulltextIndexes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForIdenticalIndexes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForOrderRandom(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @return array<float>
+     */
     public function decodePoint(string $wkb): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<float> $result */
+        $result = $this->delegateFeature(Feature\Spatial::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @return array<array<float>>
+     */
     public function decodeLinestring(string $wkb): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<array<float>> $result */
+        $result = $this->delegateFeature(Feature\Spatial::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * @return array<array<array<float>>>
+     */
     public function decodePolygon(string $wkb): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForObject(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForObjectIndexes(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<array<array<float>>> $result */
+        $result = $this->delegateFeature(Feature\Spatial::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function castingBefore(Document $collection, Document $document): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegateFeature(Feature\InternalCasting::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function castingAfter(Document $collection, Document $document): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForInternalCasting(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForUTCCasting(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegateFeature(Feature\InternalCasting::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function setUTCDatetime(string $value): mixed
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        return $this->delegateFeature(Feature\UTCCasting::class, __FUNCTION__, \func_get_args());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function setSupportForAttributes(bool $support): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * Set the authorization instance used for permission checks.
+     *
+     * @param Authorization $authorization The authorization instance
+     * @return self
+     */
     public function setAuthorization(Authorization $authorization): self
     {
         $this->authorization = $authorization;
+
         return $this;
     }
 
-    public function getSupportForAlterLocks(): bool
+    /**
+     * {@inheritDoc}
+     */
+    public function getSupportNonUtfCharacters(): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportNonUtfCharacters(): bool
+    /**
+     * @param  array<mixed>  $bindings
+     * @return array<Document>
+     */
+    public function rawQuery(string $query, array $bindings = []): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegateFeature(Feature\RawQuery::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportForTTLIndexes(): bool
+    /**
+     * @param  array<mixed>  $bindings
+     */
+    public function rawMutation(string $query, array $bindings = []): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegateFeature(Feature\RawQuery::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportForTransactionRetries(): bool
+    public function getBuilder(string $collection): \Utopia\Query\Builder
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var \Utopia\Query\Builder $result */
+        $result = $this->delegateFeature(Feature\QueryBuilder::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportForNestedTransactions(): bool
+    public function getSchema(): \Utopia\Query\Schema
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var \Utopia\Query\Schema $result */
+        $result = $this->delegateFeature(Feature\QueryBuilder::class, __FUNCTION__, \func_get_args());
+        return $result;
     }
+
+    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    {
+        /** @var string $result */
+        $result = $this->delegateFeature(Feature\ColumnTypes::class, __FUNCTION__, \func_get_args());
+        return $result;
+    }
+
 }
diff --git a/src/Database/Adapter/Postgres.php b/src/Database/Adapter/Postgres.php
index 1241123264..6c6648bd14 100644
--- a/src/Database/Adapter/Postgres.php
+++ b/src/Database/Adapter/Postgres.php
@@ -2,23 +2,45 @@
 
 namespace Utopia\Database\Adapter;
 
+use DateTime;
 use Exception;
 use PDO;
 use PDOException;
+use PDOStatement;
+use Swoole\Database\PDOStatementProxy;
+use Throwable;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
 use Utopia\Database\Exception\Operator as OperatorException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
-use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Exception\Unique as UniqueException;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Hook\PermissionFilter;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Builder\PostgreSQL as PostgreSQLBuilder;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\Method;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\PostgreSQL as PostgreSQLSchema;
 
 /**
  * Differences between MariaDB and Postgres
@@ -28,89 +50,70 @@
  * 3. DATETIME is TIMESTAMP
  * 4. Full-text search is different - to_tsvector() and to_tsquery()
  */
-class Postgres extends SQL
+class Postgres extends SQL implements Feature\ConnectionId, Feature\Spatial, Feature\Timeouts
 {
     public const MAX_IDENTIFIER_NAME = 63;
 
     /**
-     * @inheritDoc
+     * Get the list of capabilities supported by the PostgreSQL adapter.
+     *
+     * @return array<Capability>
      */
-    public function rollbackTransaction(): bool
+    public function capabilities(): array
     {
-        if ($this->inTransaction === 0) {
-            return false;
-        }
-
-        try {
-            if ($this->inTransaction > 1) {
-                $this->getPDO()->exec('ROLLBACK TO transaction' . ($this->inTransaction - 1));
-                $this->inTransaction--;
-                return true;
-            }
-
-            $result = $this->getPDO()->rollBack();
-            $this->inTransaction = 0;
-        } catch (PDOException $e) {
-            $this->inTransaction = 0;
-            throw new DatabaseException('Failed to rollback transaction: ' . $e->getMessage(), $e->getCode(), $e);
-        }
-
-        if (!$result) {
-            throw new TransactionException('Failed to rollback transaction');
-        }
-
-        return $result;
+        return array_merge(parent::capabilities(), [
+            Capability::Vectors,
+            Capability::Objects,
+            Capability::SpatialIndexNull,
+            Capability::MultiDimensionDistance,
+            Capability::TrigramIndex,
+            Capability::POSIX,
+            Capability::ObjectIndexes,
+            Capability::Upserts,
+        ]);
     }
 
-    protected function execute(mixed $stmt): bool
+    /**
+     * Get the case-insensitive LIKE operator for PostgreSQL.
+     *
+     * @return string
+     */
+    public function getLikeOperator(): string
     {
-        $pdo = $this->getPDO();
-
-        // Choose the right SET command based on transaction state
-        $sql = $this->inTransaction === 0
-            ? "SET statement_timeout = '{$this->timeout}ms'"
-            : "SET LOCAL statement_timeout = '{$this->timeout}ms'";
-
-        // Apply timeout
-        $pdo->exec($sql);
-
-        try {
-            return $stmt->execute();
-        } finally {
-            // Only reset the global timeout when not in a transaction
-            if ($this->inTransaction === 0) {
-                $pdo->exec("RESET statement_timeout");
-            }
-        }
+        return 'ILIKE';
     }
 
-
+    /**
+     * Get the POSIX regex matching operator for PostgreSQL.
+     *
+     * @return string
+     */
+    public function getRegexOperator(): string
+    {
+        return '~';
+    }
 
     /**
-     * Returns Max Execution Time
-     * @param int $milliseconds
-     * @param string $event
-     * @return void
-     * @throws DatabaseException
+     * Get the PostgreSQL backend process ID as the connection identifier.
+     *
+     * @return string
      */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    public function getConnectionId(): string
     {
-        if (!$this->getSupportForTimeouts()) {
-            return;
-        }
-        if ($milliseconds <= 0) {
-            throw new DatabaseException('Timeout must be greater than 0');
+        $result = $this->createBuilder()->fromNone()->selectRaw('pg_backend_pid()')->build();
+        $stmt = $this->getPDO()->query($result->query);
+        if ($stmt === false) {
+            return '';
         }
+        $col = $stmt->fetchColumn();
 
-        $this->timeout = $milliseconds;
+        return \is_scalar($col) ? (string) $col : '';
     }
 
     /**
      * Create Database
      *
-     * @param string $name
      *
-     * @return bool
      * @throws DatabaseException
      */
     public function create(string $name): bool
@@ -121,207 +124,218 @@ public function create(string $name): bool
             return true;
         }
 
-        $sql = "CREATE SCHEMA \"{$name}\"";
-        $sql = $this->trigger(Database::EVENT_DATABASE_CREATE, $sql);
+        $schema = $this->createSchemaBuilder();
+        $sql = $schema->createDatabase($name)->query;
+
+        $dbCreation = $this->executeStatement($sql, Event::DatabaseCreate);
 
-        $dbCreation = $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        // Enable extensions — wrap in try-catch to handle concurrent creation race conditions
+        foreach (['postgis', 'vector', 'pg_trgm'] as $ext) {
+            try {
+                $this->executeStatement($schema->createExtension($ext)->query, Event::DatabaseCreate);
+            } catch (PDOException) {
+                // Extension may already exist due to concurrent worker
+            }
+        }
 
-        // Enable extensions
-        $this->getPDO()->prepare('CREATE EXTENSION IF NOT EXISTS postgis')->execute();
-        $this->getPDO()->prepare('CREATE EXTENSION IF NOT EXISTS vector')->execute();
-        $this->getPDO()->prepare('CREATE EXTENSION IF NOT EXISTS pg_trgm')->execute();
+        try {
+            $collation = $schema->createCollation('utf8_ci_ai', [
+                'provider' => 'icu',
+                'locale' => 'und-u-ks-level1',
+            ], deterministic: false);
+            $this->executeStatement($collation->query, Event::DatabaseCreate);
+        } catch (PDOException) {
+            // Collation may already exist due to concurrent worker
+        }
 
-        $collation = "
-            CREATE COLLATION IF NOT EXISTS utf8_ci_ai (
-            provider = icu,
-            locale = 'und-u-ks-level1',
-            deterministic = false
-            )
-        ";
-        $this->getPDO()->prepare($collation)->execute();
         return $dbCreation;
     }
 
     /**
-     * Delete Database
-     *
-     * @param string $name
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
+     * Override to use lowercase catalog names for Postgres case sensitivity.
      */
-    public function delete(string $name): bool
+    #[\Override]
+    public function exists(string $database, ?string $collection = null): bool
     {
-        $name = $this->filter($name);
+        $database = $this->filter($database);
 
-        $sql = "DROP SCHEMA IF EXISTS \"{$name}\" CASCADE";
-        $sql = $this->trigger(Database::EVENT_DATABASE_DELETE, $sql);
+        if ($collection !== null) {
+            $sql = 'SELECT "table_name" FROM information_schema.tables WHERE "table_schema" = ? AND "table_name" = ?';
+            $stmt = $this->prepareStatement($sql, Event::CollectionRead);
+            $stmt->bindValue(1, $database);
+            $stmt->bindValue(2, $this->getPhysicalTableName($collection));
+        } else {
+            $sql = 'SELECT "schema_name" FROM information_schema.schemata WHERE "schema_name" = ?';
+            $stmt = $this->prepareStatement($sql, Event::DatabaseList);
+            $stmt->bindValue(1, $database);
+        }
+
+        try {
+            $this->execute($stmt);
+            $document = $stmt->fetchAll();
+            $stmt->closeCursor();
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
 
-        return $this->getPDO()->prepare($sql)->execute();
+        return ! empty($document);
     }
 
     /**
      * Create Collection
      *
-     * @param string $name
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     * @param  array<Index>  $indexes
+     *
      * @throws DuplicateException
      */
     public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
     {
         $namespace = $this->getNamespace();
         $id = $this->filter($name);
+        $tableRaw = $this->getSQLTableRaw($id);
+        $permsTableRaw = $this->getSQLTableRaw(Storage::permissionsTable($id));
 
-        /** @var array<string> $attributeStrings */
-        $attributeStrings = [];
-        foreach ($attributes as $attribute) {
-            $attrId = $this->filter($attribute->getId());
-
-            $attrType = $this->getSQLType(
-                $attribute->getAttribute('type'),
-                $attribute->getAttribute('size', 0),
-                $attribute->getAttribute('signed', true),
-                $attribute->getAttribute('array', false),
-                $attribute->getAttribute('required', false)
-            );
+        $schema = $this->createSchemaBuilder();
+
+        $table = $schema->table($tableRaw);
+        $table->id(Storage::SEQUENCE);
+        $table->string(Storage::UID, 255);
+
+        if ($this->sharedTables) {
+            $table->integer(Storage::TENANT)->nullable()->default(null);
+        }
+
+        $table->datetime(Storage::CREATED_AT, 3)->nullable()->default(null);
+        $table->datetime(Storage::UPDATED_AT, 3)->nullable()->default(null);
 
-            // Ignore relationships with virtual attributes
-            if ($attribute->getAttribute('type') === Database::VAR_RELATIONSHIP) {
-                $options = $attribute->getAttribute('options', []);
+        foreach ($attributes as $attribute) {
+            if ($attribute->type === ColumnType::Relationship) {
+                $options = $attribute->options ?? [];
                 $relationType = $options['relationType'] ?? null;
                 $twoWay = $options['twoWay'] ?? false;
                 $side = $options['side'] ?? null;
 
                 if (
-                    $relationType === Database::RELATION_MANY_TO_MANY
-                    || ($relationType === Database::RELATION_ONE_TO_ONE && !$twoWay && $side === Database::RELATION_SIDE_CHILD)
-                    || ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT)
-                    || ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD)
+                    $relationType === RelationType::ManyToMany->value
+                    || ($relationType === RelationType::OneToOne->value && ! $twoWay && $side === RelationSide::Child->value)
+                    || ($relationType === RelationType::OneToMany->value && $side === RelationSide::Parent->value)
+                    || ($relationType === RelationType::ManyToOne->value && $side === RelationSide::Child->value)
                 ) {
                     continue;
                 }
             }
 
-            $attributeStrings[] = "\"{$attrId}\" {$attrType}, ";
+            $this->addTableColumn(
+                $table,
+                $attribute->key,
+                $attribute->type,
+                $attribute->size,
+                $attribute->signed,
+                $attribute->array,
+                $attribute->required
+            );
         }
 
-        $sqlTenant = $this->sharedTables ? '_tenant INTEGER DEFAULT NULL,' : '';
-        $collection = "
-            CREATE TABLE {$this->getSQLTable($id)} (
-                _id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
-                _uid VARCHAR(255) NOT NULL,
-                " . $sqlTenant . "
-                \"_createdAt\" TIMESTAMP(3) DEFAULT NULL,
-                \"_updatedAt\" TIMESTAMP(3) DEFAULT NULL,
-                " . \implode(' ', $attributeStrings) . "
-                _permissions JSONB DEFAULT NULL
-            );
-        ";
+        $table->json(Storage::PERMISSIONS)->nullable()->default(null);
+        $table->integer(Storage::VERSION)->nullable()->default(1);
+        $collectionResult = $table->create();
+
+        // Build default indexes using schema builder
+        $indexStatements = [];
 
         if ($this->sharedTables) {
-            $uidIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_uid");
+            $uidIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}".Storage::UID);
             $createdIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_created");
             $updatedIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_updated");
-            $tenantIdIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_tenant_id");
-            $permissionsIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_permissions");
-            $collection .= "
-				CREATE UNIQUE INDEX \"{$uidIndex}\" ON {$this->getSQLTable($id)} (\"_uid\" COLLATE utf8_ci_ai, \"_tenant\");
-            	CREATE INDEX \"{$createdIndex}\" ON {$this->getSQLTable($id)} (_tenant, \"_createdAt\");
-            	CREATE INDEX \"{$updatedIndex}\" ON {$this->getSQLTable($id)} (_tenant, \"_updatedAt\");
-            	CREATE INDEX \"{$tenantIdIndex}\" ON {$this->getSQLTable($id)} (_tenant, _id);
-            	CREATE INDEX \"{$permissionsIndex}\" ON {$this->getSQLTable($id)} USING gin (_permissions);
-			";
+            $tenantIdIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}".Storage::INDEX_TENANT_ID);
+            $permissionsIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}".Storage::PERMISSIONS);
+            $indexStatements[] = $schema->createIndex($tableRaw, $uidIndex, [Storage::UID, Storage::TENANT], unique: true, collations: [Storage::UID => 'utf8_ci_ai'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $createdIndex, [Storage::TENANT, Storage::CREATED_AT])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $updatedIndex, [Storage::TENANT, Storage::UPDATED_AT])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $tenantIdIndex, [Storage::TENANT, Storage::SEQUENCE])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $permissionsIndex, [Storage::PERMISSIONS], method: 'gin')->query;
         } else {
-            $uidIndex = $this->getShortKey("{$namespace}_{$id}_uid");
+            $uidIndex = $this->getShortKey("{$namespace}_{$id}".Storage::UID);
             $createdIndex = $this->getShortKey("{$namespace}_{$id}_created");
             $updatedIndex = $this->getShortKey("{$namespace}_{$id}_updated");
-            $permissionsIndex = $this->getShortKey("{$namespace}_{$id}_permissions");
-            $collection .= "
-				CREATE UNIQUE INDEX \"{$uidIndex}\" ON {$this->getSQLTable($id)} (\"_uid\" COLLATE utf8_ci_ai);
-            	CREATE INDEX \"{$createdIndex}\" ON {$this->getSQLTable($id)} (\"_createdAt\");
-            	CREATE INDEX \"{$updatedIndex}\" ON {$this->getSQLTable($id)} (\"_updatedAt\");
-            	CREATE INDEX \"{$permissionsIndex}\" ON {$this->getSQLTable($id)} USING gin (_permissions);
-			";
-        }
-
-        $collection = $this->trigger(Database::EVENT_COLLECTION_CREATE, $collection);
-
-        $permissions = "
-            CREATE TABLE {$this->getSQLTable($id . '_perms')} (
-                _id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
-                _tenant INTEGER DEFAULT NULL,
-                _type VARCHAR(12) NOT NULL,
-                _permission VARCHAR(255) NOT NULL,
-                _document VARCHAR(255) NOT NULL
-            );
-        ";
+            $permissionsIndex = $this->getShortKey("{$namespace}_{$id}".Storage::PERMISSIONS);
+            $indexStatements[] = $schema->createIndex($tableRaw, $uidIndex, [Storage::UID], unique: true, collations: [Storage::UID => 'utf8_ci_ai'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $createdIndex, [Storage::CREATED_AT])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $updatedIndex, [Storage::UPDATED_AT])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $permissionsIndex, [Storage::PERMISSIONS], method: 'gin')->query;
+        }
+
+        $collectionSql = $collectionResult->query.'; '.implode('; ', $indexStatements);
+
+        $permsTable = $schema->table($permsTableRaw);
+        $permsTable->id(Storage::SEQUENCE);
+        $permsTable->integer(Storage::TENANT)->nullable()->default(null);
+        $permsTable->string(Storage::PERM_TYPE, 12);
+        $permsTable->string(Storage::PERM_PERMISSION, 255);
+        $permsTable->string(Storage::PERM_DOCUMENT, 255);
+        $permsResult = $permsTable->create();
+
+        // Build permission indexes using schema builder
+        $permsIndexStatements = [];
 
         if ($this->sharedTables) {
             $uniquePermissionIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_ukey");
             $permissionIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_permission");
-            $permissions .= "
-                CREATE UNIQUE INDEX \"{$uniquePermissionIndex}\" 
-                    ON {$this->getSQLTable($id . '_perms')} USING btree (_tenant,_document,_type,_permission);
-                CREATE INDEX \"{$permissionIndex}\" 
-                    ON {$this->getSQLTable($id . '_perms')} USING btree (_tenant,_permission,_type); 
-            ";
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $uniquePermissionIndex, [Storage::TENANT, Storage::PERM_DOCUMENT, Storage::PERM_TYPE, Storage::PERM_PERMISSION], unique: true, method: 'btree')->query;
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $permissionIndex, [Storage::TENANT, Storage::PERM_PERMISSION, Storage::PERM_TYPE], method: 'btree')->query;
         } else {
             $uniquePermissionIndex = $this->getShortKey("{$namespace}_{$id}_ukey");
             $permissionIndex = $this->getShortKey("{$namespace}_{$id}_permission");
-            $permissions .= "
-                CREATE UNIQUE INDEX \"{$uniquePermissionIndex}\" 
-                    ON {$this->getSQLTable($id . '_perms')} USING btree (_document COLLATE utf8_ci_ai,_type,_permission);
-                CREATE INDEX \"{$permissionIndex}\" 
-                    ON {$this->getSQLTable($id . '_perms')} USING btree (_permission,_type); 
-            ";
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $uniquePermissionIndex, [Storage::PERM_DOCUMENT, Storage::PERM_TYPE, Storage::PERM_PERMISSION], unique: true, method: 'btree', collations: [Storage::PERM_DOCUMENT => 'utf8_ci_ai'])->query;
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $permissionIndex, [Storage::PERM_PERMISSION, Storage::PERM_TYPE], method: 'btree')->query;
         }
 
-        $permissions = $this->trigger(Database::EVENT_COLLECTION_CREATE, $permissions);
+        $permsSql = $permsResult->query.'; '.implode('; ', $permsIndexStatements);
 
         try {
-            $this->getPDO()->prepare($collection)->execute();
-
-            $this->getPDO()->prepare($permissions)->execute();
+            $this->executeStatement($collectionSql, Event::CollectionCreate);
+            $this->executeStatement($permsSql, Event::CollectionCreate);
 
             foreach ($indexes as $index) {
-                $indexId = $this->filter($index->getId());
-                $indexType = $index->getAttribute('type');
-                $indexAttributes = $index->getAttribute('attributes', []);
+                $indexId = $this->filter($index->key);
+                $indexType = $index->type;
+                $indexAttributes = $index->attributes;
                 $indexAttributesWithType = [];
                 foreach ($indexAttributes as $indexAttribute) {
                     foreach ($attributes as $attribute) {
-                        if ($attribute->getId() === $indexAttribute) {
-                            $indexAttributesWithType[$indexAttribute] = $attribute->getAttribute('type');
+                        if ($attribute->key === $indexAttribute) {
+                            $indexAttributesWithType[$indexAttribute] = $attribute->type->value;
                         }
                     }
                 }
-                $indexOrders = $index->getAttribute('orders', []);
-                $indexTtl = $index->getAttribute('ttl', 0);
-                if ($indexType === Database::INDEX_SPATIAL && count($indexOrders)) {
+                $indexOrders = $index->orders;
+                $indexTtl = $index->ttl;
+                if ($indexType === IndexType::Spatial && count($indexOrders)) {
                     throw new DatabaseException('Spatial indexes with explicit orders are not supported. Remove the orders to create this index.');
                 }
                 $this->createIndex(
                     $id,
-                    $indexId,
-                    $indexType,
-                    $indexAttributes,
-                    [],
-                    $indexOrders,
+                    new Index(
+                        key: $indexId,
+                        type: $indexType,
+                        attributes: $indexAttributes,
+                        orders: $indexOrders,
+                        ttl: $indexTtl,
+                    ),
                     $indexAttributesWithType,
-                    [],
-                    $indexTtl
+                    event: Event::CollectionCreate,
                 );
             }
+        } catch (DuplicateException $e) {
+            throw $e;
         } catch (PDOException $e) {
             $e = $this->processException($e);
 
-            if (!($e instanceof DuplicateException)) {
-                $this->execute($this->getPDO()
-                    ->prepare("DROP TABLE IF EXISTS {$this->getSQLTable($id)}, {$this->getSQLTable($id . '_perms')};"));
+            if (! ($e instanceof DuplicateException)) {
+                $dropSchema = $this->createSchemaBuilder();
+                $dropSql = $dropSchema->table($tableRaw)->dropIfExists()->query.'; '.$dropSchema->table($permsTableRaw)->dropIfExists()->query;
+                $this->executeStatement($dropSql, Event::CollectionCreate);
             }
 
             throw $e;
@@ -332,144 +346,186 @@ public function createCollection(string $name, array $attributes = [], array $in
 
     /**
      * Get Collection Size on disk
-     * @param string $collection
-     * @return int
+     *
      * @throws DatabaseException
      */
     public function getSizeOfCollectionOnDisk(string $collection): int
     {
         $collection = $this->filter($collection);
         $name = $this->getSQLTable($collection);
-        $permissions = $this->getSQLTable($collection . '_perms');
+        $permissions = $this->getSQLTable(Storage::permissionsTable($collection));
 
-        $collectionSize = $this->getPDO()->prepare("
-             SELECT pg_total_relation_size(:name);
-        ");
+        $builder = $this->createBuilder();
 
-        $permissionsSize = $this->getPDO()->prepare("
-             SELECT pg_total_relation_size(:permissions);
-        ");
+        $collectionResult = $builder->fromNone()->selectRaw('pg_total_relation_size(?)', [$name])->build();
+        $permissionsResult = $builder->reset()->fromNone()->selectRaw('pg_total_relation_size(?)', [$permissions])->build();
 
-        $collectionSize->bindParam(':name', $name);
-        $permissionsSize->bindParam(':permissions', $permissions);
+        $collectionSize = $this->executeResult($collectionResult, Event::CollectionRead);
+        $permissionsSize = $this->executeResult($permissionsResult, Event::CollectionRead);
+
+        foreach ($collectionResult->bindings as $i => $v) {
+            $collectionSize->bindValue($i + 1, $v);
+        }
+        foreach ($permissionsResult->bindings as $i => $v) {
+            $permissionsSize->bindValue($i + 1, $v);
+        }
 
         try {
             $this->execute($collectionSize);
             $this->execute($permissionsSize);
-            $size = $collectionSize->fetchColumn() + $permissionsSize->fetchColumn();
+            $collVal = $collectionSize->fetchColumn();
+            $permVal = $permissionsSize->fetchColumn();
+            $size = (int)(\is_numeric($collVal) ? $collVal : 0) + (int)(\is_numeric($permVal) ? $permVal : 0);
         } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
         }
 
-        return  $size;
+        return $size;
     }
 
     /**
      * Get Collection Size of raw data
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
      *
+     * @throws DatabaseException
      */
     public function getSizeOfCollection(string $collection): int
     {
         $collection = $this->filter($collection);
         $name = $this->getSQLTable($collection);
-        $permissions = $this->getSQLTable($collection . '_perms');
+        $permissions = $this->getSQLTable(Storage::permissionsTable($collection));
+
+        $builder = $this->createBuilder();
 
-        $collectionSize = $this->getPDO()->prepare("
-             SELECT pg_relation_size(:name);
-        ");
+        $collectionResult = $builder->fromNone()->selectRaw('pg_relation_size(?)', [$name])->build();
+        $permissionsResult = $builder->reset()->fromNone()->selectRaw('pg_relation_size(?)', [$permissions])->build();
 
-        $permissionsSize = $this->getPDO()->prepare("
-             SELECT pg_relation_size(:permissions);
-        ");
+        $collectionSize = $this->executeResult($collectionResult, Event::CollectionRead);
+        $permissionsSize = $this->executeResult($permissionsResult, Event::CollectionRead);
 
-        $collectionSize->bindParam(':name', $name);
-        $permissionsSize->bindParam(':permissions', $permissions);
+        foreach ($collectionResult->bindings as $i => $v) {
+            $collectionSize->bindValue($i + 1, $v);
+        }
+        foreach ($permissionsResult->bindings as $i => $v) {
+            $permissionsSize->bindValue($i + 1, $v);
+        }
 
         try {
             $this->execute($collectionSize);
             $this->execute($permissionsSize);
-            $size = $collectionSize->fetchColumn() + $permissionsSize->fetchColumn();
+            $collVal = $collectionSize->fetchColumn();
+            $permVal = $permissionsSize->fetchColumn();
+            $size = (int)(\is_numeric($collVal) ? $collVal : 0) + (int)(\is_numeric($permVal) ? $permVal : 0);
         } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
+            throw new DatabaseException('Failed to get collection size: '.$e->getMessage());
         }
 
-        return  $size;
+        return $size;
     }
 
     /**
-     * Delete Collection
+     * Create Attribute
+     *
      *
-     * @param string $id
-     * @return bool
+     * @throws DatabaseException
      */
-    public function deleteCollection(string $id): bool
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        $id = $this->filter($id);
+        // Ensure pgvector extension is installed for vector types
+        if ($attribute->type === ColumnType::Vector) {
+            if ($attribute->size <= 0) {
+                throw new DatabaseException('Vector dimensions must be a positive integer');
+            }
+            if ($attribute->size > Database::MAX_VECTOR_DIMENSIONS) {
+                throw new DatabaseException('Vector dimensions cannot exceed '.Database::MAX_VECTOR_DIMENSIONS);
+            }
+        }
+
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $this->addTableColumn($table, $attribute->key, $attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        $result = $table->alter();
 
-        $sql = "DROP TABLE {$this->getSQLTable($id)}, {$this->getSQLTable($id . '_perms')}";
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
+        // Postgres does not support LOCK= on ALTER TABLE, so no lock type appended
+        $sql = $result->query;
 
         try {
-            return $this->getPDO()->prepare($sql)->execute();
+            $ok = $this->executeStatement($sql, Event::AttributeCreate);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
     }
 
     /**
-     * Analyze a collection updating it's metadata on the database engine
+     * Update Attribute
      *
-     * @param string $collection
-     * @return bool
+     * @throws Exception
+     * @throws PDOException
      */
-    public function analyzeCollection(string $collection): bool
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
     {
-        return false;
-    }
+        $name = $this->filter($collection);
+        $id = $this->filter($attribute->key);
+        $newKey = empty($newKey) ? null : $this->filter($newKey);
 
-    /**
-     * Create Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     *
-     * @return bool
-     * @throws DatabaseException
-     */
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
-    {
-        // Ensure pgvector extension is installed for vector types
-        if ($type === Database::VAR_VECTOR) {
-            if ($size <= 0) {
+        if ($attribute->type === ColumnType::Vector) {
+            if ($attribute->size <= 0) {
                 throw new DatabaseException('Vector dimensions must be a positive integer');
             }
-            if ($size > Database::MAX_VECTOR_DIMENSIONS) {
-                throw new DatabaseException('Vector dimensions cannot exceed ' . Database::MAX_VECTOR_DIMENSIONS);
+            if ($attribute->size > Database::MAX_VECTOR_DIMENSIONS) {
+                throw new DatabaseException('Vector dimensions cannot exceed '.Database::MAX_VECTOR_DIMENSIONS);
             }
         }
 
-        $name = $this->filter($collection);
-        $id = $this->filter($id);
-        $type = $this->getSQLType($type, $size, $signed, $array, $required);
+        $schema = $this->createSchemaBuilder();
+
+        // Rename column first if needed
+        if (! empty($newKey) && $id !== $newKey) {
+            $newKey = $this->filter($newKey);
+
+            $renameTable = $schema->table($this->getSQLTableRaw($collection));
+            $renameTable->renameColumn($id, $newKey);
+            $renameResult = $renameTable->alter();
+
+            $sql = $renameResult->query;
+
+            $result = $this->executeStatement($sql, Event::AttributeUpdate);
+
+            // Rename mutates the schema. Invalidate now so a subsequent
+            // alterColumnType failure can't leave the cache pointing at the
+            // pre-rename column id.
+            $this->invalidateSpatialAttributesCache($collection);
+
+            if (! $result) {
+                return false;
+            }
 
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($name)}
-			ADD COLUMN \"{$id}\" {$type}
-		";
+            $id = $newKey;
+        }
+
+        // Modify column type using schema builder's alterColumnType
+        $sqlType = $this->getSQLType($attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        $tableRaw = $this->getSQLTableRaw($name);
+
+        if ($sqlType == 'TIMESTAMP(3)') {
+            $result = $schema->alterColumnType($tableRaw, $id, 'TIMESTAMP(3)', "TO_TIMESTAMP(\"{$id}\", 'YYYY-MM-DD HH24:MI:SS.MS')");
+        } else {
+            $result = $schema->alterColumnType($tableRaw, $id, $sqlType);
+        }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+        $sql = $result->query;
 
         try {
-            return $this->execute($this->getPDO()
-                ->prepare($sql));
+            $ok = $this->executeStatement($sql, Event::AttributeUpdate);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
+            // alterColumnType can partially modify the column; drop the cache
+            // so the next read rescans live schema.
+            $this->invalidateSpatialAttributesCache($collection);
             throw $this->processException($e);
         }
     }
@@ -477,30 +533,27 @@ public function createAttribute(string $collection, string $id, string $type, in
     /**
      * Delete Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param bool $array
      *
-     * @return bool
      * @throws DatabaseException
      */
-    public function deleteAttribute(string $collection, string $id, bool $array = false): bool
+    public function deleteAttribute(string $collection, string $id): bool
     {
-        $name = $this->filter($collection);
-        $id = $this->filter($id);
-
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($name)}
-			DROP COLUMN \"{$id}\";
-		";
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $table->dropColumn($this->filter($id));
+        $result = $table->alter();
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $sql);
+        $sql = $result->query;
 
         try {
-            return $this->execute($this->getPDO()
-                ->prepare($sql));
+            $ok = $this->executeStatement($sql, Event::AttributeDelete);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
-            if ($e->getCode() === "42703" && $e->errorInfo[1] === 7) {
+            if ($e->getCode() === '42703' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+                $this->invalidateSpatialAttributesCache($collection);
+
                 return true;
             }
 
@@ -511,1103 +564,947 @@ public function deleteAttribute(string $collection, string $id, bool $array = fa
     /**
      * Rename Attribute
      *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
     public function renameAttribute(string $collection, string $old, string $new): bool
     {
-        $collection = $this->filter($collection);
-        $old = $this->filter($old);
-        $new = $this->filter($new);
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $table->renameColumn($this->filter($old), $this->filter($new));
+        $result = $table->alter();
 
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($collection)} 
-			RENAME COLUMN \"{$old}\" TO \"{$new}\"
-		";
+        $sql = $result->query;
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+        $ok = $this->executeStatement($sql, Event::AttributeUpdate);
+        $this->invalidateSpatialAttributesCache($collection);
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        return $ok;
     }
 
     /**
-     * Update Attribute
+     * Create Index
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $newKey
-     * @param bool $required
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
+     * @param  array<string,string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
      */
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
-    {
-        $name = $this->filter($collection);
-        $id = $this->filter($id);
-        $newKey = empty($newKey) ? null : $this->filter($newKey);
-
-        if ($type === Database::VAR_VECTOR) {
-            if ($size <= 0) {
-                throw new DatabaseException('Vector dimensions must be a positive integer');
-            }
-            if ($size > Database::MAX_VECTOR_DIMENSIONS) {
-                throw new DatabaseException('Vector dimensions cannot exceed ' . Database::MAX_VECTOR_DIMENSIONS);
-            }
-        }
+    public function createIndex(
+        string $collection,
+        Index $index,
+        array $indexAttributeTypes = [],
+        array $collation = [],
+        Event $event = Event::IndexCreate,
+    ): bool {
+        $collection = $this->filter($collection);
+        $id = $this->filter($index->key);
+        $type = $index->type;
+        $attributes = $index->attributes;
+        $orders = $index->orders;
+
+        // Validate index type
+        match ($type) {
+            IndexType::Key,
+            IndexType::Fulltext,
+            IndexType::Spatial,
+            IndexType::HnswEuclidean,
+            IndexType::HnswCosine,
+            IndexType::HnswDot,
+            IndexType::Object,
+            IndexType::Trigram,
+            IndexType::Unique => true,
+            default => throw new DatabaseException('Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value.', '.IndexType::Spatial->value.', '.IndexType::Object->value.', '.IndexType::HnswEuclidean->value.', '.IndexType::HnswCosine->value.', '.IndexType::HnswDot->value),
+        };
 
-        $type = $this->getSQLType(
-            $type,
-            $size,
-            $signed,
-            $array,
-            $required,
-        );
+        $keyName = $this->getShortKey("{$this->getNamespace()}_{$this->tenant}_{$collection}_{$id}");
+        $tableRaw = $this->getSQLTableRaw($collection);
+        $schema = $this->createSchemaBuilder();
 
-        if ($type == 'TIMESTAMP(3)') {
-            $type = "TIMESTAMP(3) without time zone USING TO_TIMESTAMP(\"$id\", 'YYYY-MM-DD HH24:MI:SS.MS')";
-        }
+        // Build column lists, separating regular columns from raw JSONB path expressions
+        $columnNames = [];
+        $columnOrders = [];
+        $rawExpressions = [];
 
-        if (!empty($newKey) && $id !== $newKey) {
-            $newKey = $this->filter($newKey);
+        foreach ($attributes as $i => $attr) {
+            $order = $type === IndexType::Fulltext ? '' : Index::direction($orders[$i] ?? null);
+            $isNestedPath = isset($indexAttributeTypes[$attr]) && \str_contains($attr, '.') && $indexAttributeTypes[$attr] === ColumnType::Object->value;
 
-            $sql = "
-                    ALTER TABLE {$this->getSQLTable($name)}
-                    RENAME COLUMN \"{$id}\" TO \"{$newKey}\"
-                ";
+            if ($isNestedPath) {
+                $rawExpressions[] = $this->buildJsonbPath($attr, true).($order ? " {$order}" : '');
+            } else {
+                $attr = $this->filter($this->getInternalKeyForAttribute($attr));
+                $columnNames[] = $attr;
+                if (! empty($order)) {
+                    $columnOrders[$attr] = $order;
+                }
+            }
+        }
 
-            $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+        if ($this->sharedTables && \in_array($type, [IndexType::Key, IndexType::Unique])) {
+            \array_unshift($columnNames, Storage::TENANT);
+        }
 
-            $result = $this->execute($this->getPDO()
-                ->prepare($sql));
+        $unique = $type === IndexType::Unique;
 
-            if (!$result) {
-                return false;
-            }
+        $method = match ($type) {
+            IndexType::Spatial => 'gist',
+            IndexType::Object => 'gin',
+            IndexType::Trigram => 'gin',
+            IndexType::HnswEuclidean,
+            IndexType::HnswCosine,
+            IndexType::HnswDot => 'hnsw',
+            default => '',
+        };
 
-            $id = $newKey;
-        }
+        $operatorClass = match ($type) {
+            IndexType::HnswEuclidean => 'vector_l2_ops',
+            IndexType::HnswCosine => 'vector_cosine_ops',
+            IndexType::HnswDot => 'vector_ip_ops',
+            IndexType::Trigram => 'gin_trgm_ops',
+            default => '',
+        };
 
-        $sql = "
-                ALTER TABLE {$this->getSQLTable($name)}
-                ALTER COLUMN \"{$id}\" TYPE {$type}
-            ";
+        $sql = $schema->createIndex(
+            $tableRaw,
+            $keyName,
+            $columnNames,
+            unique: $unique,
+            method: $method,
+            operatorClass: $operatorClass,
+            orders: $columnOrders,
+            rawColumns: $rawExpressions,
+        )->query;
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
 
         try {
-            $result = $this->execute($this->getPDO()
-                ->prepare($sql));
-
-            return $result;
+            return $this->executeStatement($sql, $event);
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
     }
 
     /**
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param string $relatedCollection
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @return bool
+     * Delete Index
+     *
+     *
      * @throws Exception
      */
-    public function createRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay = false,
-        string $id = '',
-        string $twoWayKey = ''
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
+    public function deleteIndex(string $collection, string $id): bool
+    {
+        $collection = $this->filter($collection);
         $id = $this->filter($id);
-        $twoWayKey = $this->filter($twoWayKey);
-        $sqlType = $this->getSQLType(Database::VAR_RELATIONSHIP, 0, false, false, false);
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                $sql = "ALTER TABLE {$table} ADD COLUMN \"{$id}\" {$sqlType} DEFAULT NULL;";
+        $keyName = $this->getShortKey("{$this->getNamespace()}_{$this->tenant}_{$collection}_{$id}");
+        $schemaQualifiedName = $this->getDatabase().'.'.$keyName;
 
-                if ($twoWay) {
-                    $sql .= "ALTER TABLE {$relatedTable} ADD COLUMN \"{$twoWayKey}\" {$sqlType} DEFAULT NULL;";
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                $sql = "ALTER TABLE {$relatedTable} ADD COLUMN \"{$twoWayKey}\" {$sqlType} DEFAULT NULL;";
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                $sql = "ALTER TABLE {$table} ADD COLUMN \"{$id}\" {$sqlType} DEFAULT NULL;";
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                return true;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+        $schema = $this->createSchemaBuilder();
+        $sql = $schema->dropIndex($this->getSQLTableRaw($collection), $schemaQualifiedName)->query;
+        // Add IF EXISTS since the schema builder's dropIndex does not include it
+        $sql = str_replace('DROP INDEX', 'DROP INDEX IF EXISTS', $sql);
+
+        return $this->executeStatement($sql, Event::IndexDelete);
+    }
+
+    /**
+     * Rename Index
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function renameIndex(string $collection, string $old, string $new): bool
+    {
+        $collection = $this->filter($collection);
+        $namespace = $this->getNamespace();
+        $old = $this->filter($old);
+        $new = $this->filter($new);
+        $schemaName = $this->getDatabase();
+        $oldIndexName = $this->getShortKey("{$namespace}_{$this->tenant}_{$collection}_{$old}");
+        $newIndexName = $this->getShortKey("{$namespace}_{$this->tenant}_{$collection}_{$new}");
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+        $schemaBuilder = $this->createSchemaBuilder();
+        $schemaQualifiedOld = $schemaName.'.'.$oldIndexName;
+        $sql = $schemaBuilder->renameIndex($this->getSQLTableRaw($collection), $schemaQualifiedOld, $newIndexName)->query;
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        return $this->executeStatement($sql, Event::IndexRename);
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @param string|null $newKey
-     * @param string|null $newTwoWayKey
-     * @return bool
-     * @throws DatabaseException
+     * Create Document
      */
-    public function updateRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side,
-        ?string $newKey = null,
-        ?string $newTwoWayKey = null,
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
+    public function createDocument(Document $collection, Document $document): Document
+    {
+        try {
+            $this->syncWriteHooks();
+
+            $spatialAttributes = $this->getSpatialAttributes($collection);
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = \json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
+            }
 
-        if (!\is_null($newKey)) {
-            $newKey = $this->filter($newKey);
-        }
-        if (!\is_null($newTwoWayKey)) {
-            $newTwoWayKey = $this->filter($newTwoWayKey);
-        }
+            $name = $this->filter($collection);
 
-        $sql = '';
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($key !== $newKey) {
-                    $sql = "ALTER TABLE {$table} RENAME COLUMN \"{$key}\" TO \"{$newKey}\";";
-                }
-                if ($twoWay && $twoWayKey !== $newTwoWayKey) {
-                    $sql .= "ALTER TABLE {$relatedTable} RENAME COLUMN \"{$twoWayKey}\" TO \"{$newTwoWayKey}\";";
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    if ($twoWayKey !== $newTwoWayKey) {
-                        $sql = "ALTER TABLE {$relatedTable} RENAME COLUMN \"{$twoWayKey}\" TO \"{$newTwoWayKey}\";";
-                    }
-                } else {
-                    if ($key !== $newKey) {
-                        $sql = "ALTER TABLE {$table} RENAME COLUMN \"{$key}\" TO \"{$newKey}\";";
-                    }
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    if ($twoWayKey !== $newTwoWayKey) {
-                        $sql = "ALTER TABLE {$relatedTable} RENAME COLUMN \"{$twoWayKey}\" TO \"{$newTwoWayKey}\";";
-                    }
+            $row = [Storage::UID => $document->getId()];
+            if (! empty($document->getSequence())) {
+                $row[Storage::SEQUENCE] = $document->getSequence();
+            }
+
+            foreach ($spatialAttributes as $spatialCol) {
+                $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
+            }
+
+            $spatialMap = \array_fill_keys($spatialAttributes, true);
+
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
+
+                if (isset($spatialMap[$attr]) || $this->isSpatialWkt($value)) {
+                    $row[$column] = $this->encodeSpatialWriteValue($value);
+                    $builder->insertColumnExpression($column, $this->getSpatialGeomFromText('?'));
                 } else {
-                    if ($key !== $newKey) {
-                        $sql = "ALTER TABLE {$table} RENAME COLUMN \"{$key}\" TO \"{$newKey}\";";
+                    if (\is_array($value)) {
+                        $value = \json_encode($value);
                     }
+                    $row[$column] = $value;
                 }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
+            }
 
-                $junction = $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence());
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
 
-                if (!\is_null($newKey)) {
-                    $sql = "ALTER TABLE {$junction} RENAME COLUMN \"{$key}\" TO \"{$newKey}\";";
-                }
-                if ($twoWay && !\is_null($newTwoWayKey)) {
-                    $sql .= "ALTER TABLE {$junction} RENAME COLUMN \"{$twoWayKey}\" TO \"{$newTwoWayKey}\";";
-                }
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+            $this->execute($stmt);
+            $lastInsertedId = $this->getPDO()->lastInsertId();
+            $document[Document::SEQUENCE] ??= $lastInsertedId;
 
-        if (empty($sql)) {
-            return true;
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, [$document], $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
-
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        return $document;
     }
 
     /**
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @return bool
-     * @throws DatabaseException
+     * Update Document
+     *
+     *
+     * @throws DatabaseException
+     * @throws DuplicateException
      */
-    public function deleteRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
-        $table = $this->getSQLTable($name);
-        $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
-
-        $sql = '';
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN \"{$key}\";";
-                    if ($twoWay) {
-                        $sql .= "ALTER TABLE {$relatedTable} DROP COLUMN \"{$twoWayKey}\";";
-                    }
-                } elseif ($side === Database::RELATION_SIDE_CHILD) {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN \"{$twoWayKey}\";";
-                    if ($twoWay) {
-                        $sql .= "ALTER TABLE {$table} DROP COLUMN \"{$key}\";";
-                    }
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN \"{$twoWayKey}\";";
-                } else {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN \"{$key}\";";
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    $sql = "ALTER TABLE {$relatedTable} DROP COLUMN \"{$twoWayKey}\";";
-                } else {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN \"{$key}\";";
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
-
-                $junction = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence())
-                    : $this->getSQLTable('_' . $relatedCollection->getSequence() . '_' . $collection->getSequence());
-
-                $perms = $side === Database::RELATION_SIDE_PARENT
-                    ? $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence() . '_perms')
-                    : $this->getSQLTable('_' . $relatedCollection->getSequence() . '_' . $collection->getSequence() . '_perms');
-
-                $sql = "DROP TABLE {$junction}; DROP TABLE {$perms}";
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
+    {
+        try {
+            $this->syncWriteHooks();
+
+            $spatialAttributes = $this->getSpatialAttributes($collection);
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = \json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
+            }
 
-        if (empty($sql)) {
-            return true;
-        }
+            $name = $this->filter($collection);
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $sql);
+            $operators = [];
+            foreach ($attributes as $attribute => $value) {
+                if (Operator::isOperator($value)) {
+                    $operators[$attribute] = $value;
+                }
+            }
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
-    }
+            $builder = $this->newBuilder($name);
+            $row = [];
+            if (\strcasecmp($document->getId(), $id) !== 0) {
+                $row[Storage::UID] = $document->getId();
+            }
 
-    /**
-     * Create Index
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param array<string,string> $indexAttributeTypes
-
-     * @return bool
-     */
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
-    {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
+            $spatialMap = \array_fill_keys($spatialAttributes, true);
 
-        foreach ($attributes as $i => $attr) {
-            $order = empty($orders[$i]) || Database::INDEX_FULLTEXT === $type ? '' : $orders[$i];
-            $isNestedPath = isset($indexAttributeTypes[$attr]) && \str_contains($attr, '.') && $indexAttributeTypes[$attr] === Database::VAR_OBJECT;
-            if ($isNestedPath) {
-                $attributes[$i] = $this->buildJsonbPath($attr, true) . ($order ? " {$order}" : '');
-            } else {
-                $attr = $this->getInternalKeyForAttribute($attr);
-                $attr = $this->filter($attr);
+            foreach ($attributes as $attribute => $value) {
+                $column = $this->filter($attribute);
 
-                $attributes[$i] = "\"{$attr}\" {$order}";
+                if (isset($operators[$attribute])) {
+                    $op = $operators[$attribute];
+                    if ($op instanceof Operator) {
+                        $opResult = $this->getOperatorBuilderExpression($column, $op);
+                        $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
+                    }
+                } elseif (isset($spatialMap[$attribute]) || $this->isSpatialWkt($value)) {
+                    $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$this->encodeSpatialWriteValue($value)]);
+                } else {
+                    if (\is_array($value)) {
+                        $value = \json_encode($value);
+                    }
+                    $row[$column] = $value;
+                }
             }
-        }
-
-        $sqlType = match ($type) {
-            Database::INDEX_KEY,
-            Database::INDEX_FULLTEXT,
-            Database::INDEX_SPATIAL,
-            Database::INDEX_HNSW_EUCLIDEAN,
-            Database::INDEX_HNSW_COSINE,
-            Database::INDEX_HNSW_DOT,
-            Database::INDEX_OBJECT,
-            Database::INDEX_TRIGRAM => 'INDEX',
-            Database::INDEX_UNIQUE => 'UNIQUE INDEX',
-            default => throw new DatabaseException('Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT . ', ' . Database::INDEX_SPATIAL . ', ' . Database::INDEX_OBJECT . ', ' . Database::INDEX_HNSW_EUCLIDEAN . ', ' . Database::INDEX_HNSW_COSINE . ', ' . Database::INDEX_HNSW_DOT),
-        };
 
-        $keyName = $this->getShortKey("{$this->getNamespace()}_{$this->tenant}_{$collection}_{$id}");
-        $attributes = \implode(', ', $attributes);
-
-        if ($this->sharedTables && \in_array($type, [Database::INDEX_KEY, Database::INDEX_UNIQUE])) {
-            // Add tenant as first index column for best performance
-            $attributes = "_tenant, {$attributes}";
-        }
-
-        $sql = "CREATE {$sqlType} \"{$keyName}\" ON {$this->getSQLTable($collection)}";
-
-        // Add USING clause for special index types
-        $sql .= match ($type) {
-            Database::INDEX_SPATIAL => " USING GIST ({$attributes})",
-            Database::INDEX_HNSW_EUCLIDEAN => " USING HNSW ({$attributes} vector_l2_ops)",
-            Database::INDEX_HNSW_COSINE => " USING HNSW ({$attributes} vector_cosine_ops)",
-            Database::INDEX_HNSW_DOT => " USING HNSW ({$attributes} vector_ip_ops)",
-            Database::INDEX_OBJECT => " USING GIN ({$attributes})",
-            Database::INDEX_TRIGRAM =>
-                " USING GIN (" . implode(', ', array_map(
-                    fn ($attr) => "$attr gin_trgm_ops",
-                    array_map(fn ($attr) => trim($attr), explode(',', $attributes))
-                )) . ")",
-            default => " ({$attributes})",
-        };
+            $builder->set($row);
+            $builder->filter([BaseQuery::equal(Storage::SEQUENCE, [$document->getSequence()])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-        $sql = $this->trigger(Database::EVENT_INDEX_CREATE, $sql);
+            $this->execute($stmt);
 
-        try {
-            return $this->getPDO()->prepare($sql)->execute();
+            $ctx = $this->buildWriteContext($name, $id);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpdate($name, $document, $skipPermissions, $ctx));
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
+
+        return $document;
     }
+
     /**
-     * Delete Index
-     *
-     * @param string $collection
-     * @param string $id
+     * Returns Max Execution Time
      *
-     * @return bool
-     * @throws Exception
+     * @throws DatabaseException
      */
-    public function deleteIndex(string $collection, string $id): bool
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
-        $schemaName = $this->getDatabase();
-
-        $keyName = $this->getShortKey("{$this->getNamespace()}_{$this->tenant}_{$collection}_{$id}");
+        if ($milliseconds <= 0) {
+            throw new DatabaseException('Timeout must be greater than 0');
+        }
 
-        $sql = "DROP INDEX IF EXISTS \"{$schemaName}\".\"{$keyName}\"";
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
+        $this->setTimeoutState($milliseconds, $event);
+    }
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        $this->clearTimeoutState($event);
     }
 
     /**
-     * Rename Index
+     * Get the minimum supported datetime value for PostgreSQL.
      *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
+     * @return DateTime
      */
-    public function renameIndex(string $collection, string $old, string $new): bool
+    public function getMinDateTime(): DateTime
     {
-        $collection = $this->filter($collection);
-        $namespace = $this->getNamespace();
-        $old = $this->filter($old);
-        $new = $this->filter($new);
-        $schema = $this->getDatabase();
-        $oldIndexName = $this->getShortKey("{$namespace}_{$this->tenant}_{$collection}_{$old}");
-        $newIndexName = $this->getShortKey("{$namespace}_{$this->tenant}_{$collection}_{$new}");
-
-        $sql = "ALTER INDEX \"{$schema}\".\"{$oldIndexName}\" RENAME TO \"{$newIndexName}\"";
-        $sql = $this->trigger(Database::EVENT_INDEX_RENAME, $sql);
-
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        return new DateTime('-4713-01-01 00:00:00');
     }
 
     /**
-     * Create Document
+     * Decode a WKB or WKT POINT into a coordinate array [x, y].
      *
-     * @param Document $collection
-     * @param Document $document
+     * @param string $wkb The WKB hex or WKT string
+     * @return array<float>
      *
-     * @return Document
+     * @throws DatabaseException If the input is invalid.
      */
-    public function createDocument(Document $collection, Document $document): Document
+    #[\Override]
+    public function decodePoint(string $wkb): array
     {
-        $collection = $collection->getId();
-        $attributes = $document->getAttributes();
-        $attributes['_createdAt'] = $document->getCreatedAt();
-        $attributes['_updatedAt'] = $document->getUpdatedAt();
-        $attributes['_permissions'] = \json_encode($document->getPermissions());
-
-        if ($this->sharedTables) {
-            $attributes['_tenant'] = $document->getTenant();
-        }
+        if (str_starts_with(strtoupper($wkb), 'POINT(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, $end - $start);
 
-        $name = $this->filter($collection);
-        $columns = '';
-        $columnNames = '';
+            $coords = explode(' ', trim($inside));
 
-        // Insert internal id if set
-        if (!empty($document->getSequence())) {
-            $bindKey = '_id';
-            $columns .= "\"_id\", ";
-            $columnNames .= ':' . $bindKey . ', ';
+            return [(float) $coords[0], (float) $coords[1]];
         }
 
-        $bindIndex = 0;
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
-            $bindKey = 'key_' . $bindIndex;
-            $columns .= "\"{$column}\", ";
-            $columnNames .= ':' . $bindKey . ', ';
-            $bindIndex++;
+        $bin = hex2bin($wkb);
+        if ($bin === false) {
+            throw new DatabaseException('Invalid hex WKB string');
         }
 
-        $sql = "
-			INSERT INTO {$this->getSQLTable($name)} ({$columns} \"_uid\")
-			VALUES ({$columnNames} :_uid)
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_CREATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        $stmt->bindValue(':_uid', $document->getId(), PDO::PARAM_STR);
-
-        if (!empty($document->getSequence())) {
-            $stmt->bindValue(':_id', $document->getSequence(), PDO::PARAM_STR);
+        if (strlen($bin) < 13) { // 1 byte endian + 4 bytes type + 8 bytes for X
+            throw new DatabaseException('WKB too short');
         }
 
-        $attributeIndex = 0;
-        foreach ($attributes as $value) {
-            if (\is_array($value)) {
-                $value = \json_encode($value);
-            }
+        $isLE = ord($bin[0]) === 1;
 
-            $bindKey = 'key_' . $attributeIndex;
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $attributeIndex++;
+        // Type (4 bytes)
+        $typeBytes = substr($bin, 1, 4);
+        if (strlen($typeBytes) !== 4) {
+            throw new DatabaseException('Failed to extract type bytes from WKB');
         }
 
-        $permissions = [];
-        foreach (Database::PERMISSIONS as $type) {
-            foreach ($document->getPermissionsByType($type) as $permission) {
-                $permission = \str_replace('"', '', $permission);
-                $sqlTenant = $this->sharedTables ? ', :_tenant' : '';
-                $permissions[] = "('{$type}', '{$permission}', :_uid {$sqlTenant})";
-            }
+        $typeArr = unpack($isLE ? 'V' : 'N', $typeBytes);
+        if ($typeArr === false || ! isset($typeArr[1])) {
+            throw new DatabaseException('Failed to unpack type from WKB');
         }
+        $type = \is_numeric($typeArr[1]) ? (int) $typeArr[1] : 0;
 
+        // Offset to coordinates (skip SRID if present)
+        $offset = 5 + (($type & 0x20000000) ? 4 : 0);
 
-        if (!empty($permissions)) {
-            $permissions = \implode(', ', $permissions);
-            $sqlTenant = $this->sharedTables ? ', _tenant' : '';
+        if (strlen($bin) < $offset + 16) { // 16 bytes for X,Y
+            throw new DatabaseException('WKB too short for coordinates');
+        }
 
-            $queryPermissions = "
-				INSERT INTO {$this->getSQLTable($name . '_perms')} (_type, _permission, _document {$sqlTenant})
-				VALUES {$permissions}
-			";
+        $fmt = $isLE ? 'e' : 'E'; // little vs big endian double
 
-            $queryPermissions = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $queryPermissions);
-            $stmtPermissions = $this->getPDO()->prepare($queryPermissions);
-            $stmtPermissions->bindValue(':_uid', $document->getId());
-            if ($sqlTenant) {
-                $stmtPermissions->bindValue(':_tenant', $document->getTenant());
-            }
+        // X coordinate
+        $xArr = unpack($fmt, substr($bin, $offset, 8));
+        if ($xArr === false || ! isset($xArr[1])) {
+            throw new DatabaseException('Failed to unpack X coordinate');
         }
+        $x = \is_numeric($xArr[1]) ? (float) $xArr[1] : 0.0;
 
-        try {
-            $this->execute($stmt);
-            $lastInsertedId = $this->getPDO()->lastInsertId();
-            // Sequence can be manually set as well
-            $document['$sequence'] ??= $lastInsertedId;
-
-            if (isset($stmtPermissions)) {
-                $this->execute($stmtPermissions);
-            }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        // Y coordinate
+        $yArr = unpack($fmt, substr($bin, $offset + 8, 8));
+        if ($yArr === false || ! isset($yArr[1])) {
+            throw new DatabaseException('Failed to unpack Y coordinate');
         }
+        $y = \is_numeric($yArr[1]) ? (float) $yArr[1] : 0.0;
 
-        return $document;
+        return [$x, $y];
     }
 
     /**
-     * Update Document
+     * Decode a WKB or WKT LINESTRING into an array of coordinate pairs.
      *
+     * @param mixed $wkb The WKB binary or WKT string
+     * @return array<array<float>>
      *
-     * @param Document $collection
-     * @param string $id
-     * @param Document $document
-     * @param bool $skipPermissions
-     * @return Document
-     * @throws DatabaseException
-     * @throws DuplicateException
+     * @throws DatabaseException If the input is invalid.
      */
-    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
+    #[\Override]
+    public function decodeLinestring(mixed $wkb): array
     {
-        $spatialAttributes = $this->getSpatialAttributes($collection);
-        $collection = $collection->getId();
-        $attributes = $document->getAttributes();
-        $attributes['_createdAt'] = $document->getCreatedAt();
-        $attributes['_updatedAt'] = $document->getUpdatedAt();
-        $attributes['_permissions'] = json_encode($document->getPermissions());
-        $attributes['_uid'] = $document->getId();
-
-        $name = $this->filter($collection);
-        $columns = '';
-
-        if (!$skipPermissions) {
-            $newUid = $document->offsetExists('$id') ? $document->getId() : $id;
-
-            $sql = "
-			DELETE FROM {$this->getSQLTable($name . '_perms')}
-			WHERE _document = :_uid
-			{$this->getTenantQuery($collection)}
-		";
-
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
-
-            $stmtRemovePermissions = $this->getPDO()->prepare($sql);
-            $stmtRemovePermissions->bindValue(':_uid', $id);
-            if ($this->sharedTables) {
-                $stmtRemovePermissions->bindValue(':_tenant', $document->getTenant());
-            }
-
-            $values = [];
-            $binds = [];
-            foreach (Database::PERMISSIONS as $type) {
-                foreach ($document->getPermissionsByType($type) as $i => $permission) {
-                    $sqlTenant = $this->sharedTables ? ', :_tenant' : '';
-                    $values[] = "( :_uid, '{$type}', :_add_{$type}_{$i} {$sqlTenant})";
-                    $binds[":_add_{$type}_{$i}"] = $permission;
-                }
-            }
-
-            if (!empty($values)) {
-                $sqlTenant = $this->sharedTables ? ', _tenant' : '';
-
-                $sql = "
-				INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission {$sqlTenant})
-				VALUES " . \implode(', ', $values);
+        $wkb = \is_string($wkb) ? $wkb : '';
+        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, (int) $end - $start);
 
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
+            $points = explode(',', $inside);
 
-                $stmtAddPermissions = $this->getPDO()->prepare($sql);
-                $stmtAddPermissions->bindValue(":_uid", $newUid);
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(':_tenant', $document->getTenant());
-                }
+            return array_map(function ($point) {
+                $coords = explode(' ', trim($point));
 
-                foreach ($binds as $key => $permission) {
-                    $stmtAddPermissions->bindValue($key, $permission);
-                }
-            }
+                return [(float) $coords[0], (float) $coords[1]];
+            }, $points);
         }
 
-        /**
-         * Update Attributes
-         */
-
-        $keyIndex = 0;
-        $operatorBinds = [];
-
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
-
-            // Check if this is an operator, spatial attribute, or regular attribute
-            if (Operator::isOperator($value)) {
-                $operatorSQL = $this->getOperatorSQL($column, $value, $operatorBinds);
-                $columns .= $operatorSQL . ',';
-            } elseif (\in_array($attribute, $spatialAttributes, true)) {
-                $bindKey = 'key_' . $keyIndex;
-                $columns .= "\"{$column}\" = " . $this->getSpatialGeomFromText(':' . $bindKey) . ',';
-                $keyIndex++;
-            } else {
-                $bindKey = 'key_' . $keyIndex;
-                $columns .= "\"{$column}\"" . '=:' . $bindKey . ',';
-                $keyIndex++;
+        if (ctype_xdigit($wkb)) {
+            $wkb = hex2bin($wkb);
+            if ($wkb === false) {
+                throw new DatabaseException('Failed to convert hex WKB to binary.');
             }
         }
 
-        $sql = "
-			UPDATE {$this->getSQLTable($name)}
-			SET " . \rtrim($columns, ',') . "
-			WHERE _id=:_sequence
-			{$this->getTenantQuery($collection)}
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        $stmt->bindValue(':_sequence', $document->getSequence());
+        if (strlen($wkb) < 9) {
+            throw new DatabaseException('WKB too short to be a valid geometry');
+        }
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+        $byteOrder = ord($wkb[0]);
+        if ($byteOrder === 0) {
+            throw new DatabaseException('Big-endian WKB not supported');
+        } elseif ($byteOrder !== 1) {
+            throw new DatabaseException('Invalid byte order in WKB');
         }
 
-        $keyIndex = 0;
-        foreach ($attributes as $attribute => $value) {
-            // Handle operators separately
-            if (Operator::isOperator($value)) {
-                continue;
-            }
+        // Type + SRID flag
+        $typeField = unpack('V', substr($wkb, 1, 4));
+        if ($typeField === false) {
+            throw new DatabaseException('Failed to unpack the type field from WKB.');
+        }
 
-            // Convert spatial arrays to WKT, json_encode non-spatial arrays
-            if (\in_array($attribute, $spatialAttributes, true)) {
-                if (\is_array($value)) {
-                    $value = $this->convertArrayToWKT($value);
-                }
-            } elseif (is_array($value)) {
-                $value = json_encode($value);
-            }
+        $typeField = \is_numeric($typeField[1]) ? (int) $typeField[1] : 0;
+        $geomType = $typeField & 0xFF;
+        $hasSRID = ($typeField & 0x20000000) !== 0;
 
-            $bindKey = 'key_' . $keyIndex;
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $keyIndex++;
+        if ($geomType !== 2) { // 2 = LINESTRING
+            throw new DatabaseException("Not a LINESTRING geometry type, got {$geomType}");
         }
 
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
+        $offset = 5;
+        if ($hasSRID) {
+            $offset += 4;
         }
 
-        try {
-            $this->execute($stmt);
-            if (isset($stmtRemovePermissions)) {
-                $this->execute($stmtRemovePermissions);
-            }
-            if (isset($stmtAddPermissions)) {
-                $this->execute($stmtAddPermissions);
-            }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        $numPoints = unpack('V', substr($wkb, $offset, 4));
+        if ($numPoints === false) {
+            throw new DatabaseException("Failed to unpack number of points at offset {$offset}.");
         }
 
-        return $document;
-    }
-
-    /**
-     * @param string $tableName
-     * @param string $columns
-     * @param array<string> $batchKeys
-     * @param array<string> $attributes
-     * @param array<mixed> $bindValues
-     * @param string $attribute
-     * @param array<Operator> $operators
-     * @return mixed
-     */
-    protected function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = [],
-    ): mixed {
-        $getUpdateClause = function (string $attribute, bool $increment = false): string {
-            $attribute = $this->quote($this->filter($attribute));
-            if ($increment) {
-                $new = "target.{$attribute} + EXCLUDED.{$attribute}";
-            } else {
-                $new = "EXCLUDED.{$attribute}";
-            }
+        $numPoints = \is_numeric($numPoints[1]) ? (int) $numPoints[1] : 0;
+        $offset += 4;
 
-            if ($this->sharedTables) {
-                return "{$attribute} = CASE WHEN target._tenant = EXCLUDED._tenant THEN {$new} ELSE target.{$attribute} END";
+        $points = [];
+        for ($i = 0; $i < $numPoints; $i++) {
+            $x = unpack('e', substr($wkb, $offset, 8));
+            if ($x === false) {
+                throw new DatabaseException("Failed to unpack X coordinate at offset {$offset}.");
             }
 
-            return "{$attribute} = {$new}";
-        };
+            $x = \is_numeric($x[1]) ? (float) $x[1] : 0.0;
 
-        $operatorBinds = [];
+            $offset += 8;
 
-        if (!empty($attribute)) {
-            // Increment specific column by its new value in place
-            $updateColumns = [
-                $getUpdateClause($attribute, increment: true),
-                $getUpdateClause('_updatedAt'),
-            ];
-        } else {
-            // Update all columns and apply operators
-            $updateColumns = [];
-            foreach (array_keys($attributes) as $attr) {
-                /**
-                 * @var string $attr
-                 */
-                $filteredAttr = $this->filter($attr);
-
-                // Check if this attribute has an operator
-                if (isset($operators[$attr])) {
-                    $operatorSQL = $this->getOperatorSQL($filteredAttr, $operators[$attr], $operatorBinds, useTargetPrefix: true);
-                    if ($operatorSQL !== null) {
-                        $updateColumns[] = $operatorSQL;
-                    }
-                } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
-                        $updateColumns[] = $getUpdateClause($filteredAttr);
-                    }
-                }
+            $y = unpack('e', substr($wkb, $offset, 8));
+            if ($y === false) {
+                throw new DatabaseException("Failed to unpack Y coordinate at offset {$offset}.");
             }
-        }
-
-        $conflictKeys = $this->sharedTables ? '("_uid", _tenant)' : '("_uid")';
-
-        $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} AS target {$columns}
-            VALUES " . implode(', ', $batchKeys) . "
-            ON CONFLICT {$conflictKeys} DO UPDATE
-                SET " . implode(', ', $updateColumns)
-        );
 
-        foreach ($bindValues as $key => $binding) {
-            $stmt->bindValue($key, $binding, $this->getPDOType($binding));
-        }
+            $y = \is_numeric($y[1]) ? (float) $y[1] : 0.0;
 
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
+            $offset += 8;
+            $points[] = [$x, $y];
         }
 
-        return $stmt;
+        return $points;
     }
 
     /**
-     * Increase or decrease an attribute value
+     * Decode a WKB or WKT POLYGON into an array of rings, each containing coordinate pairs.
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $attribute
-     * @param int|float $value
-     * @param string $updatedAt
-     * @param int|float|null $min
-     * @param int|float|null $max
-     * @return bool
-     * @throws DatabaseException
+     * @param string $wkb The WKB hex or WKT string
+     * @return array<array<array<float>>>
+     *
+     * @throws DatabaseException If the input is invalid.
      */
-    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value, string $updatedAt, int|float|null $min = null, int|float|null $max = null): bool
+    #[\Override]
+    public function decodePolygon(string $wkb): array
     {
-        $name = $this->filter($collection);
-        $attribute = $this->filter($attribute);
-
-        $sqlMax = $max !== null ? " AND \"{$attribute}\" <= :max" : "";
-        $sqlMin = $min !== null ? " AND \"{$attribute}\" >= :min" : "";
-
-        $sql = "
-			UPDATE {$this->getSQLTable($name)}
-			SET
-			    \"{$attribute}\" = \"{$attribute}\" + :val,
-                \"_updatedAt\" = :updatedAt
-			WHERE _uid = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+        // POLYGON((x1,y1),(x2,y2))
+        if (str_starts_with($wkb, 'POLYGON((')) {
+            $start = strpos($wkb, '((') + 2;
+            $end = strrpos($wkb, '))');
+            $inside = substr($wkb, $start, $end - $start);
 
-        $sql .= $sqlMax . $sqlMin;
+            $rings = explode('),(', $inside);
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
+            return array_map(function ($ring) {
+                $points = explode(',', $ring);
 
-        $stmt = $this->getPDO()->prepare($sql);
-        $stmt->bindValue(':_uid', $id);
-        $stmt->bindValue(':val', $value);
-        $stmt->bindValue(':updatedAt', $updatedAt);
+                return array_map(function ($point) {
+                    $coords = explode(' ', trim($point));
 
-        if ($max !== null) {
-            $stmt->bindValue(':max', $max);
-        }
-        if ($min !== null) {
-            $stmt->bindValue(':min', $min);
+                    return [(float) $coords[0], (float) $coords[1]];
+                }, $points);
+            }, $rings);
         }
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+
+        // Convert hex string to binary if needed
+        if (preg_match('/^[0-9a-fA-F]+$/', $wkb)) {
+            $wkb = hex2bin($wkb);
+            if ($wkb === false) {
+                throw new DatabaseException('Invalid hex WKB');
+            }
+        }
+
+        if (strlen($wkb) < 9) {
+            throw new DatabaseException('WKB too short');
+        }
+
+        $uInt32 = 'V'; // little-endian 32-bit unsigned
+        $uDouble = 'd'; // little-endian double
+
+        $typeInt = unpack($uInt32, substr($wkb, 1, 4));
+        if ($typeInt === false) {
+            throw new DatabaseException('Failed to unpack type field from WKB.');
+        }
+
+        $typeInt = \is_numeric($typeInt[1]) ? (int) $typeInt[1] : 0;
+        $hasSrid = ($typeInt & 0x20000000) !== 0;
+        $geomType = $typeInt & 0xFF;
+
+        if ($geomType !== 3) { // 3 = POLYGON
+            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
+        }
+
+        $offset = 5;
+        if ($hasSrid) {
+            $offset += 4;
+        }
+
+        // Number of rings
+        $numRings = unpack($uInt32, substr($wkb, $offset, 4));
+        if ($numRings === false) {
+            throw new DatabaseException('Failed to unpack number of rings from WKB.');
+        }
+
+        $numRings = \is_numeric($numRings[1]) ? (int) $numRings[1] : 0;
+        $offset += 4;
+
+        $rings = [];
+        for ($r = 0; $r < $numRings; $r++) {
+            $numPoints = unpack($uInt32, substr($wkb, $offset, 4));
+            if ($numPoints === false) {
+                throw new DatabaseException('Failed to unpack number of points from WKB.');
+            }
+
+            $numPoints = \is_numeric($numPoints[1]) ? (int) $numPoints[1] : 0;
+            $offset += 4;
+            $points = [];
+            for ($i = 0; $i < $numPoints; $i++) {
+                $x = unpack($uDouble, substr($wkb, $offset, 8));
+                if ($x === false) {
+                    throw new DatabaseException('Failed to unpack X coordinate from WKB.');
+                }
+
+                $x = \is_numeric($x[1]) ? (float) $x[1] : 0.0;
+
+                $y = unpack($uDouble, substr($wkb, $offset + 8, 8));
+                if ($y === false) {
+                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
+                }
+
+                $y = \is_numeric($y[1]) ? (float) $y[1] : 0.0;
+
+                $points[] = [$x, $y];
+                $offset += 16;
+            }
+            $rings[] = $points;
+        }
+
+        return $rings; // array of rings, each ring is array of [x,y]
+    }
+
+    /**
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
+     */
+    protected function execute(mixed $stmt, ?Event $event = null): bool
+    {
+        $pdo = $this->getPDO();
+        $event ??= $this->getStatementEvent($stmt);
+        $timeout = $event === null ? $this->getTimeout() : $this->getTimeout($event);
+
+        if ($timeout === 0) {
+            return $stmt->execute();
+        }
+
+        $sql = $this->inTransaction === 0
+            ? "SET statement_timeout = '{$timeout}ms'"
+            : "SET LOCAL statement_timeout = '{$timeout}ms'";
+
+        $pdo->exec($sql);
+
+        $exception = null;
+        try {
+            return $stmt->execute();
+        } catch (Throwable $error) {
+            $exception = $error;
+            throw $error;
+        } finally {
+            try {
+                $pdo->exec($this->inTransaction === 0
+                    ? 'RESET statement_timeout'
+                    : 'SET LOCAL statement_timeout = DEFAULT');
+            } catch (Throwable $error) {
+                if ($exception === null) {
+                    throw $error;
+                }
+            }
         }
+    }
 
-        $this->execute($stmt) || throw new DatabaseException('Failed to update attribute');
+    /**
+     * {@inheritDoc}
+     */
+    protected function insertRequiresAlias(): bool
+    {
         return true;
     }
 
     /**
-     * Delete Document
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return 'CASE WHEN target.'.Storage::TENANT.' = EXCLUDED.'.Storage::TENANT." THEN EXCLUDED.{$quoted} ELSE target.{$quoted} END";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return "target.{$quoted} + EXCLUDED.{$quoted}";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return 'CASE WHEN target.'.Storage::TENANT.' = EXCLUDED.'.Storage::TENANT." THEN target.{$quoted} + EXCLUDED.{$quoted} ELSE target.{$quoted} END";
+    }
+
+    /**
+     * Get a builder-compatible operator expression for upsert conflict resolution.
      *
-     * @param string $collection
-     * @param string $id
+     * Overrides the base implementation to use target-prefixed column references
+     * so that ON CONFLICT DO UPDATE SET expressions correctly reference the
+     * existing row via the target alias.
      *
-     * @return bool
+     * @param  string  $column  The unquoted, filtered column name
+     * @param  Operator  $operator  The operator to convert
+     * @return array{expression: string, bindings: list<mixed>}
      */
-    public function deleteDocument(string $collection, string $id): bool
+    protected function getOperatorUpsertExpression(string $column, Operator $operator): array
     {
-        $name = $this->filter($collection);
-
-        $sql = "
-			DELETE FROM {$this->getSQLTable($name)} 
-			WHERE _uid = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+        $bindIndex = 0;
+        $fullExpression = $this->getOperatorSQL($column, $operator, $bindIndex, useTargetPrefix: true);
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_DELETE, $sql);
-        $stmt = $this->getPDO()->prepare($sql);
-        $stmt->bindValue(':_uid', $id, PDO::PARAM_STR);
+        if ($fullExpression === null) {
+            throw new DatabaseException('Operator cannot be expressed in SQL: '.$operator->getMethod()->value);
+        }
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+        // Strip the "quotedColumn = " prefix to get just the RHS expression
+        $quotedColumn = $this->quote($column);
+        $prefix = $quotedColumn.' = ';
+        $expression = $fullExpression;
+        if (str_starts_with($expression, $prefix)) {
+            $expression = substr($expression, strlen($prefix));
         }
 
-        $sql = "
-			DELETE FROM {$this->getSQLTable($name . '_perms')} 
-			WHERE _document = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+        // Collect the named binding keys and their values in order
+        /** @var array<string, mixed> $namedBindings */
+        $namedBindings = [];
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+        $idx = 0;
 
-        $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
+        switch ($method) {
+            case OperatorType::Increment:
+            case OperatorType::Decrement:
+            case OperatorType::Multiply:
+            case OperatorType::Divide:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                if (isset($values[1])) {
+                    $namedBindings["op_{$idx}"] = $values[1];
+                    $idx++;
+                }
+                break;
 
-        $stmtPermissions = $this->getPDO()->prepare($sql);
-        $stmtPermissions->bindValue(':_uid', $id);
+            case OperatorType::Modulo:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                break;
 
-        if ($this->sharedTables) {
-            $stmtPermissions->bindValue(':_tenant', $this->tenant);
+            case OperatorType::Power:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                if (isset($values[1])) {
+                    $namedBindings["op_{$idx}"] = $values[1];
+                    $idx++;
+                }
+                break;
+
+            case OperatorType::StringConcat:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                break;
+
+            case OperatorType::StringReplace:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                $namedBindings["op_{$idx}"] = $values[1] ?? '';
+                $idx++;
+                break;
+
+            case OperatorType::Toggle:
+                // No bindings
+                break;
+
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                break;
+
+            case OperatorType::DateSetNow:
+                // No bindings
+                break;
+
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayRemove:
+                $value = $values[0] ?? null;
+                $namedBindings["op_{$idx}"] = json_encode($value);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayUnique:
+                // No bindings
+                break;
+
+            case OperatorType::ArrayInsert:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                $namedBindings["op_{$idx}"] = json_encode($values[1] ?? null);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayFilter:
+                $condition = $values[0] ?? 'equal';
+                $filterValue = $values[1] ?? null;
+                $namedBindings["op_{$idx}"] = $condition;
+                $idx++;
+                $namedBindings["op_{$idx}"] = $filterValue !== null ? json_encode($filterValue) : null;
+                $idx++;
+                break;
         }
 
-        $deleted = false;
+        // Replace each named binding occurrence with ? and collect positional bindings
+        $positionalBindings = [];
+        $keys = array_keys($namedBindings);
+        usort($keys, fn ($a, $b) => strlen($b) - strlen($a));
 
-        try {
-            if (!$this->execute($stmt)) {
-                throw new DatabaseException('Failed to delete document');
+        $replacements = [];
+        foreach ($keys as $key) {
+            $search = ':'.$key;
+            $offset = 0;
+            while (($pos = strpos($expression, $search, $offset)) !== false) {
+                $replacements[] = ['pos' => $pos, 'len' => strlen($search), 'key' => $key];
+                $offset = $pos + strlen($search);
             }
+        }
 
-            $deleted = $stmt->rowCount();
+        usort($replacements, fn ($a, $b) => $a['pos'] - $b['pos']);
 
-            if (!$this->execute($stmtPermissions)) {
-                throw new DatabaseException('Failed to delete permissions');
-            }
-        } catch (\Throwable $th) {
-            throw new DatabaseException($th->getMessage());
+        $result = $expression;
+        for ($i = count($replacements) - 1; $i >= 0; $i--) {
+            $r = $replacements[$i];
+            $result = substr_replace($result, '?', $r['pos'], $r['len']);
         }
 
-        return $deleted;
-    }
+        foreach ($replacements as $r) {
+            $positionalBindings[] = $namedBindings[$r['key']];
+        }
 
-    /**
-     * @return string
-     */
-    public function getConnectionId(): string
-    {
-        $stmt = $this->getPDO()->query("SELECT pg_backend_pid();");
-        return $stmt->fetchColumn();
+        return ['expression' => $result, 'bindings' => $positionalBindings];
     }
 
     /**
      * Handle distance spatial queries
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
-    */
-    protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $alias, string $placeholder): string
+     * @param  array<string, mixed>  $binds
+     */
+    protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
     {
+        /** @var array<mixed> $distanceParams */
         $distanceParams = $query->getValues()[0];
-        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($distanceParams[0]);
+        $geomArray = \is_array($distanceParams[0]) ? $distanceParams[0] : [];
+        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($geomArray);
         $binds[":{$placeholder}_1"] = $distanceParams[1];
 
         $meters = isset($distanceParams[2]) && $distanceParams[2] === true;
 
-        switch ($query->getMethod()) {
-            case Query::TYPE_DISTANCE_EQUAL:
-                $operator = '=';
-                break;
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-                $operator = '!=';
-                break;
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-                $operator = '>';
-                break;
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                $operator = '<';
-                break;
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
-        }
+        $operator = match ($query->getMethod()) {
+            Method::DistanceEqual => '=',
+            Method::DistanceNotEqual => '!=',
+            Method::DistanceGreaterThan => '>',
+            Method::DistanceLessThan => '<',
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
+        };
 
         if ($meters) {
             $attr = "({$alias}.{$attribute}::geography)";
-            $geom = "ST_SetSRID(" . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ", " . Database::DEFAULT_SRID . ")::geography";
+            $geom = 'ST_SetSRID('.$this->getSpatialGeomFromText(":{$placeholder}_0", null).', '.Database::DEFAULT_SRID.')::geography';
+
             return "ST_Distance({$attr}, {$geom}) {$operator} :{$placeholder}_1";
         }
 
         // Without meters, use the original SRID (e.g., 4326)
-        return "ST_Distance({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ") {$operator} :{$placeholder}_1";
+        return "ST_Distance({$alias}.{$attribute}, ".$this->getSpatialGeomFromText(":{$placeholder}_0").") {$operator} :{$placeholder}_1";
     }
 
-
     /**
      * Handle spatial queries
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
+     * @param  array<string, mixed>  $binds
      */
-    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $alias, string $placeholder): string
+    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
     {
-        switch ($query->getMethod()) {
-            case Query::TYPE_CROSSES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Crosses({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_NOT_CROSSES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Crosses({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_DISTANCE_EQUAL:
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                return $this->handleDistanceSpatialQueries($query, $binds, $attribute, $alias, $placeholder);
-            case Query::TYPE_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_NOT_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_NOT_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_NOT_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_NOT_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_NOT_CONTAINS:
-                // using st_cover instead of contains to match the boundary matching behaviour of the mariadb st_contains
-                // postgis st_contains excludes matching the boundary
-                $isNot = $query->getMethod() === Query::TYPE_NOT_CONTAINS;
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return $isNot
-                    ? "NOT ST_Covers({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")"
-                    : "ST_Covers({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0") . ")";
-
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
-                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
-
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
+        if (\in_array($query->getMethod(), [Method::IsNull, Method::IsNotNull], true)) {
+            return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
         }
+
+        $spatialGeomRaw = $query->getValues()[0];
+        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT(\is_array($spatialGeomRaw) ? $spatialGeomRaw : []);
+        $geom = $this->getSpatialGeomFromText(":{$placeholder}_0");
+
+        return match ($query->getMethod()) {
+            Method::Crosses => "ST_Crosses({$alias}.{$attribute}, {$geom})",
+            Method::NotCrosses => "NOT ST_Crosses({$alias}.{$attribute}, {$geom})",
+            Method::DistanceEqual,
+            Method::DistanceNotEqual,
+            Method::DistanceGreaterThan,
+            Method::DistanceLessThan => $this->handleDistanceSpatialQueries($query, $binds, $attribute, $type, $alias, $placeholder),
+            Method::Equal => "ST_Equals({$alias}.{$attribute}, {$geom})",
+            Method::NotEqual => "NOT ST_Equals({$alias}.{$attribute}, {$geom})",
+            Method::Intersects => "ST_Intersects({$alias}.{$attribute}, {$geom})",
+            Method::NotIntersects => "NOT ST_Intersects({$alias}.{$attribute}, {$geom})",
+            Method::Overlaps => "ST_Overlaps({$alias}.{$attribute}, {$geom})",
+            Method::NotOverlaps => "NOT ST_Overlaps({$alias}.{$attribute}, {$geom})",
+            Method::Touches => "ST_Touches({$alias}.{$attribute}, {$geom})",
+            Method::NotTouches => "NOT ST_Touches({$alias}.{$attribute}, {$geom})",
+            // using st_cover instead of contains to match the boundary matching behaviour of the mariadb st_contains
+            // postgis st_contains excludes matching the boundary
+            Method::Contains => "ST_Covers({$alias}.{$attribute}, {$geom})",
+            Method::NotContains => "NOT ST_Covers({$alias}.{$attribute}, {$geom})",
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
+        };
     }
 
     /**
      * Handle JSONB queries
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $alias
-     * @param string $placeholder
-     * @return string
+     * @param  array<string, mixed>  $binds
      */
     protected function handleObjectQueries(Query $query, array &$binds, string $attribute, string $alias, string $placeholder): string
     {
         switch ($query->getMethod()) {
-            case Query::TYPE_EQUAL:
-            case Query::TYPE_NOT_EQUAL: {
-                $isNot = $query->getMethod() === Query::TYPE_NOT_EQUAL;
+            case Method::Equal:
+            case Method::NotEqual:
+                $isNot = $query->getMethod() === Method::NotEqual;
                 $conditions = [];
                 foreach ($query->getValues() as $key => $value) {
                     $binds[":{$placeholder}_{$key}"] = json_encode($value);
                     $fragment = "{$alias}.{$attribute} @> :{$placeholder}_{$key}::jsonb";
-                    $conditions[] = $isNot ? "NOT (" . $fragment . ")" : $fragment;
+                    $conditions[] = $isNot ? 'NOT ('.$fragment.')' : $fragment;
                 }
                 $separator = $isNot ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
-            }
 
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
-            case Query::TYPE_CONTAINS_ALL:
-            case Query::TYPE_NOT_CONTAINS: {
-                $isNot = $query->getMethod() === Query::TYPE_NOT_CONTAINS;
+                return empty($conditions) ? '' : '('.implode($separator, $conditions).')';
+
+            case Method::Contains:
+            case Method::ContainsAny:
+            case Method::ContainsAll:
+            case Method::NotContains:
+                $isNot = $query->getMethod() === Method::NotContains;
                 $conditions = [];
                 foreach ($query->getValues() as $key => $value) {
-                    if (count($value) === 1) {
+                    if (\is_array($value) && count($value) === 1) {
                         $jsonKey = array_key_first($value);
                         $jsonValue = $value[$jsonKey];
 
@@ -1615,29 +1512,28 @@ protected function handleObjectQueries(Query $query, array &$binds, string $attr
                         // wrap it to express array containment: {"skills": ["typescript"]}
                         // If it's already an object/associative array (e.g. "config" => ["lang" => "en"]),
                         // keep as-is to express object containment.
-                        if (!\is_array($jsonValue)) {
+                        if (! \is_array($jsonValue)) {
                             $value[$jsonKey] = [$jsonValue];
                         }
                     }
                     $binds[":{$placeholder}_{$key}"] = json_encode($value);
                     $fragment = "{$alias}.{$attribute} @> :{$placeholder}_{$key}::jsonb";
-                    $conditions[] = $isNot ? "NOT (" . $fragment . ")" : $fragment;
+                    $conditions[] = $isNot ? 'NOT ('.$fragment.')' : $fragment;
                 }
                 $separator = $isNot ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
-            }
+
+                return empty($conditions) ? '' : '('.implode($separator, $conditions).')';
 
             default:
-                throw new DatabaseException('Query method ' . $query->getMethod() . ' not supported for object attributes');
+                throw new DatabaseException('Query method '.$query->getMethod()->value.' not supported for object attributes');
         }
     }
 
     /**
      * Get SQL Condition
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @return string
+     * @param  array<string, mixed>  $binds
+     *
      * @throws Exception
      */
     protected function getSQLCondition(Query $query, array &$binds, ?string $forCollection = null): string
@@ -1657,70 +1553,79 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
         $operator = null;
 
         if ($query->isSpatialAttribute()) {
-            return $this->handleSpatialQueries($query, $binds, $attribute, $alias, $placeholder);
+            return $this->handleSpatialQueries($query, $binds, $attribute, $query->getAttributeType(), $alias, $placeholder);
         }
 
-        if ($query->isObjectAttribute() && !$isNestedObjectAttribute) {
+        if ($query->isObjectAttribute() && ! $isNestedObjectAttribute) {
             return $this->handleObjectQueries($query, $binds, $attribute, $alias, $placeholder);
         }
 
         switch ($query->getMethod()) {
-            case Query::TYPE_OR:
-            case Query::TYPE_AND:
+            case Method::Or:
+            case Method::And:
                 $conditions = [];
-                /* @var $q Query */
-                foreach ($query->getValue() as $q) {
+                /** @var iterable<Query> $nestedQueries */
+                $nestedQueries = $query->getValue();
+                foreach ($nestedQueries as $q) {
                     $conditions[] = $this->getSQLCondition($q, $binds, $forCollection);
                 }
 
-                $method = strtoupper($query->getMethod());
-                return empty($conditions) ? '' : ' ' . $method . ' (' . implode(' AND ', $conditions) . ')';
+                $method = strtoupper($query->getMethod()->value);
 
-            case Query::TYPE_SEARCH:
-                $fulltextValue = $this->getFulltextValue($query->getValue());
+                return empty($conditions) ? '' : ' '.$method.' ('.implode(' AND ', $conditions).')';
+
+            case Method::Search:
+                $searchVal = $query->getValue();
+                $fulltextValue = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
                 if ($fulltextValue === '') {
                     return '0 = 1';
                 }
                 $binds[":{$placeholder}_0"] = $fulltextValue;
+
                 return "to_tsvector(regexp_replace({$attribute}, '[^\w]+',' ','g')) @@ websearch_to_tsquery(:{$placeholder}_0)";
 
-            case Query::TYPE_NOT_SEARCH:
-                $fulltextValue = $this->getFulltextValue($query->getValue());
+            case Method::NotSearch:
+                $notSearchVal = $query->getValue();
+                $fulltextValue = $this->getFulltextValue(\is_string($notSearchVal) ? $notSearchVal : '');
                 if ($fulltextValue === '') {
                     return '1 = 1';
                 }
                 $binds[":{$placeholder}_0"] = $fulltextValue;
+
                 return "NOT (to_tsvector(regexp_replace({$attribute}, '[^\w]+',' ','g')) @@ websearch_to_tsquery(:{$placeholder}_0))";
 
-            case Query::TYPE_VECTOR_DOT:
-            case Query::TYPE_VECTOR_COSINE:
-            case Query::TYPE_VECTOR_EUCLIDEAN:
+            case Method::VectorDot:
+            case Method::VectorCosine:
+            case Method::VectorEuclidean:
                 return ''; // Handled in ORDER BY clause
 
-            case Query::TYPE_BETWEEN:
+            case Method::Between:
                 $binds[":{$placeholder}_0"] = $query->getValues()[0];
                 $binds[":{$placeholder}_1"] = $query->getValues()[1];
+
                 return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-            case Query::TYPE_NOT_BETWEEN:
+            case Method::NotBetween:
                 $binds[":{$placeholder}_0"] = $query->getValues()[0];
                 $binds[":{$placeholder}_1"] = $query->getValues()[1];
+
                 return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNull:
+            case Method::IsNotNull:
                 return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
 
-            case Query::TYPE_CONTAINS_ALL:
+            case Method::ContainsAll:
                 if ($query->onArray()) {
                     // @> checks the array contains ALL specified values
                     $binds[":{$placeholder}_0"] = \json_encode($query->getValues());
+
                     return "{$alias}.{$attribute} @> :{$placeholder}_0::jsonb";
                 }
                 // no break
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
-            case Query::TYPE_NOT_CONTAINS:
+            case Method::Contains:
+            case Method::ContainsAny:
+            case Method::NotContains:
                 if ($query->onArray()) {
                     $operator = '@>';
                 }
@@ -1730,19 +1635,20 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
                 $conditions = [];
                 $operator = $operator ?? $this->getSQLOperator($query->getMethod());
                 $isNotQuery = in_array($query->getMethod(), [
-                    Query::TYPE_NOT_STARTS_WITH,
-                    Query::TYPE_NOT_ENDS_WITH,
-                    Query::TYPE_NOT_CONTAINS
+                    Method::NotStartsWith,
+                    Method::NotEndsWith,
+                    Method::NotContains,
                 ]);
 
                 foreach ($query->getValues() as $key => $value) {
+                    $strValue = \is_string($value) ? $value : '';
                     $value = match ($query->getMethod()) {
-                        Query::TYPE_STARTS_WITH => $this->escapeWildcards($value) . '%',
-                        Query::TYPE_NOT_STARTS_WITH => $this->escapeWildcards($value) . '%',
-                        Query::TYPE_ENDS_WITH => '%' . $this->escapeWildcards($value),
-                        Query::TYPE_NOT_ENDS_WITH => '%' . $this->escapeWildcards($value),
-                        Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($value) . '%',
-                        Query::TYPE_NOT_CONTAINS => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($value) . '%',
+                        Method::StartsWith => $this->escapeWildcards($strValue).'%',
+                        Method::NotStartsWith => $this->escapeWildcards($strValue).'%',
+                        Method::EndsWith => '%'.$this->escapeWildcards($strValue),
+                        Method::NotEndsWith => '%'.$this->escapeWildcards($strValue),
+                        Method::Contains, Method::ContainsAny => ($query->onArray()) ? \json_encode($value) : '%'.$this->escapeWildcards($strValue).'%',
+                        Method::NotContains => ($query->onArray()) ? \json_encode($value) : '%'.$this->escapeWildcards($strValue).'%',
                         default => $value
                     };
 
@@ -1751,7 +1657,7 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
                     if ($isNotQuery && $query->onArray()) {
                         // For array NOT queries, wrap the entire condition in NOT()
                         $conditions[] = "NOT ({$alias}.{$attribute} {$operator} :{$placeholder}_{$key})";
-                    } elseif ($isNotQuery && !$query->onArray()) {
+                    } elseif ($isNotQuery && ! $query->onArray()) {
                         $conditions[] = "{$alias}.{$attribute} NOT {$operator} :{$placeholder}_{$key}";
                     } else {
                         $conditions[] = "{$alias}.{$attribute} {$operator} :{$placeholder}_{$key}";
@@ -1759,857 +1665,345 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
                 }
 
                 $separator = $isNotQuery ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
+
+                return empty($conditions) ? '' : '('.implode($separator, $conditions).')';
         }
     }
 
     /**
-     * Get the SQL expression measuring distance between a vector attribute and the query vector
-     *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $alias
-     * @return string|null
-     * @throws DatabaseException
+     * Get SQL Type
      */
-    protected function getSQLVectorDistance(Query $query, array &$binds, string $alias): ?string
+    protected function createBuilder(): SQLBuilder
     {
-        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
+        return new PostgreSQLBuilder();
+    }
 
-        $attribute = $this->filter($query->getAttribute());
-        $attribute = $this->quote($attribute);
-        $alias = $this->quote($alias);
-        $placeholder = ID::unique();
+    #[\Override]
+    protected function createSchemaBuilder(): PostgreSQLSchema
+    {
+        return new PostgreSQLSchema();
+    }
 
-        $values = $query->getValues();
-        $vectorArray = $values[0] ?? [];
-        $vector = \json_encode(\array_map(\floatval(...), $vectorArray));
-        $binds[":vector_{$placeholder}"] = $vector;
+    protected function getSQLType(ColumnType $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    {
+        if ($array === true) {
+            return 'JSONB';
+        }
 
-        return match ($query->getMethod()) {
-            Query::TYPE_VECTOR_DOT => "({$alias}.{$attribute} <#> :vector_{$placeholder}::vector)",
-            Query::TYPE_VECTOR_COSINE => "({$alias}.{$attribute} <=> :vector_{$placeholder}::vector)",
-            Query::TYPE_VECTOR_EUCLIDEAN => "({$alias}.{$attribute} <-> :vector_{$placeholder}::vector)",
-            default => null,
+        return match ($type) {
+            ColumnType::Id => 'BIGINT',
+            ColumnType::String => $size > $this->getMaxVarcharLength() ? 'TEXT' : "VARCHAR({$size})",
+            ColumnType::Varchar => "VARCHAR({$size})",
+            ColumnType::Text,
+            ColumnType::MediumText,
+            ColumnType::LongText => 'TEXT',
+            ColumnType::Integer => $size >= 8 ? 'BIGINT' : 'INTEGER',
+            ColumnType::BigInteger => 'BIGINT',
+            ColumnType::BigSerial => 'BIGSERIAL',
+            ColumnType::Float, ColumnType::Double => 'DOUBLE PRECISION',
+            ColumnType::Boolean => 'BOOLEAN',
+            ColumnType::Relationship => 'VARCHAR(255)',
+            ColumnType::Datetime => 'TIMESTAMP(3)',
+            ColumnType::Object => 'JSONB',
+            ColumnType::Point => 'GEOMETRY(POINT,'.Database::DEFAULT_SRID.')',
+            ColumnType::Linestring => 'GEOMETRY(LINESTRING,'.Database::DEFAULT_SRID.')',
+            ColumnType::Polygon => 'GEOMETRY(POLYGON,'.Database::DEFAULT_SRID.')',
+            ColumnType::Vector => "VECTOR({$size})",
+            default => throw new DatabaseException('Unknown Type: '.$type->value.'. Must be one of '.ColumnType::String->value.', '.ColumnType::Varchar->value.', '.ColumnType::Text->value.', '.ColumnType::MediumText->value.', '.ColumnType::LongText->value.', '.ColumnType::Integer->value.', '.ColumnType::Double->value.', '.ColumnType::Boolean->value.', '.ColumnType::Datetime->value.', '.ColumnType::Relationship->value.', '.ColumnType::Object->value.', '.ColumnType::Point->value.', '.ColumnType::Linestring->value.', '.ColumnType::Polygon->value),
         };
     }
 
     /**
-     * @param string $distance
-     * @return string
+     * Get SQL schema
      */
-    protected function getSQLReadableDistance(string $distance): string
+    protected function getSQLSchema(): string
     {
-        return "{$distance}::text";
+        if (! $this->supports(Capability::Schemas)) {
+            return '';
+        }
+
+        return "\"{$this->getDatabase()}\".";
     }
 
     /**
-     * Match the permission against the copy carried on the row rather than joining the
-     * permissions table.
+     * Get PDO Type
      *
-     * Both hold the same fact, written together, but a semi join has to be resolved before
-     * anything can be ordered, which forces the whole collection to be read whenever the
-     * ordering could otherwise have come from an index. Matching on the row leaves the
-     * planner free to cost the permission against the ordering, so a selective permission
-     * drives from the GIN index and a permissive one is a cheap filter over whichever index
-     * the ordering wanted.
      *
-     * @param string $collection
-     * @param array<string> $roles
-     * @param string $alias
-     * @param string $type
-     * @return string
      * @throws DatabaseException
      */
-    protected function getSQLPermissionsCondition(
-        string $collection,
-        array $roles,
-        string $alias,
-        string $type = Database::PERMISSION_READ
-    ): string {
-        if (!\in_array($type, Database::PERMISSIONS)) {
-            throw new DatabaseException('Unknown permission type: ' . $type);
-        }
-
-        $column = "{$this->quote($alias)}.{$this->quote('_permissions')}";
-
-        // Containment rather than jsonb's ?| key operator: PDO reads a lone ? as a positional
-        // placeholder, and doubling it to escape breaks once a named placeholder is repeated,
-        // which the cursor conditions do. Each role is its own @> so the index can answer them
-        // as a BitmapOr; jsonb_exists_any would express it in one call but is not indexable.
-        $permissions = \array_map(
-            fn ($role) => "{$column} @> {$this->getPDO()->quote(\json_encode(["{$type}(\"{$role}\")"]))}::jsonb",
-            $roles
-        );
-
-        if ($permissions === []) {
-            return 'FALSE';
-        }
-
-        return '(' . \implode(' OR ', $permissions) . ')';
+    protected function getPDOType(mixed $value): int
+    {
+        return match (\gettype($value)) {
+            'string', 'double' => PDO::PARAM_STR,
+            'boolean' => PDO::PARAM_BOOL,
+            'integer' => PDO::PARAM_INT,
+            'NULL' => PDO::PARAM_NULL,
+            default => throw new DatabaseException('Unknown PDO Type for '.\gettype($value)),
+        };
     }
 
     /**
-     * @param string $value
-     * @return string
+     * Get vector distance calculation for ORDER BY clause
+     *
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws DatabaseException
      */
-    protected function getFulltextValue(string $value): string
+    protected function getVectorDistanceOrder(Query $query, array &$binds, string $alias): ?string
     {
-        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        /** Keep only unicode letters, numbers, underscores, and whitespace. */
-        $value = preg_replace('/[^\p{L}\p{N}_\s]/u', ' ', $value) ?? '';
-        $value = preg_replace('/\s+/', ' ', $value) ?? '';
-        $value = trim($value);
+        $attribute = $this->filter($query->getAttribute());
+        $attribute = $this->quote($attribute);
+        $alias = $this->quote($alias);
+        $placeholder = ID::unique();
 
-        if (empty($value)) {
-            return '';
-        }
-
-        if (!$exact) {
-            $value = str_replace(' ', ' or ', $value);
-        }
-
-        return "'" . $value . "'";
-    }
-
-    /**
-     * Get SQL Type
-     *
-     * @param string $type
-     * @param int $size in chars
-     * @param bool $signed
-     * @param bool $array
-     * @param bool $required
-     * @return string
-     * @throws DatabaseException
-     */
-    protected function getSQLType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
-    {
-        if ($array === true) {
-            return 'JSONB';
-        }
-
-        switch ($type) {
-            case Database::VAR_ID:
-                return 'BIGINT';
-
-            case Database::VAR_STRING:
-                // $size = $size * 4; // Convert utf8mb4 size to bytes
-                if ($size > $this->getMaxVarcharLength()) {
-                    return 'TEXT';
-                }
-
-                return "VARCHAR({$size})";
-
-            case Database::VAR_VARCHAR:
-                return "VARCHAR({$size})";
-
-            case Database::VAR_TEXT:
-            case Database::VAR_MEDIUMTEXT:
-            case Database::VAR_LONGTEXT:
-                return 'TEXT';  // PostgreSQL doesn't have MEDIUMTEXT/LONGTEXT, use TEXT
-
-            case Database::VAR_INTEGER:  // We don't support zerofill: https://stackoverflow.com/a/5634147/2299554
-
-                if ($size >= 8) { // INT = 4 bytes, BIGINT = 8 bytes
-                    return 'BIGINT';
-                }
-
-                return 'INTEGER';
-
-            case Database::VAR_BIGINT:
-                return 'BIGINT';
-
-            case Database::VAR_FLOAT:
-                return 'DOUBLE PRECISION';
-
-            case Database::VAR_BOOLEAN:
-                return 'BOOLEAN';
-
-            case Database::VAR_RELATIONSHIP:
-                return 'VARCHAR(255)';
-
-            case Database::VAR_DATETIME:
-                return 'TIMESTAMP(3)';
-
-            case Database::VAR_OBJECT:
-                return 'JSONB';
-
-            case Database::VAR_POINT:
-                return 'GEOMETRY(POINT,' . Database::DEFAULT_SRID . ')';
-
-            case Database::VAR_LINESTRING:
-                return 'GEOMETRY(LINESTRING,' . Database::DEFAULT_SRID . ')';
-
-            case Database::VAR_POLYGON:
-                return 'GEOMETRY(POLYGON,' . Database::DEFAULT_SRID . ')';
-
-            case Database::VAR_VECTOR:
-                return "VECTOR({$size})";
-
-            default:
-                throw new DatabaseException('Unknown Type: ' . $type . '. Must be one of ' . Database::VAR_STRING . ', ' . Database::VAR_VARCHAR . ', ' . Database::VAR_TEXT . ', ' . Database::VAR_MEDIUMTEXT . ', ' . Database::VAR_LONGTEXT . ', ' . Database::VAR_INTEGER . ', ' . Database::VAR_BIGINT . ', ' . Database::VAR_FLOAT . ', ' . Database::VAR_BOOLEAN . ', ' . Database::VAR_DATETIME . ', ' . Database::VAR_RELATIONSHIP . ', ' . Database::VAR_OBJECT . ', ' . Database::VAR_POINT . ', ' . Database::VAR_LINESTRING . ', ' . Database::VAR_POLYGON);
-        }
-    }
-
-    /**
-     * Get SQL schema
-     *
-     * @return string
-     */
-    protected function getSQLSchema(): string
-    {
-        if (!$this->getSupportForSchemas()) {
-            return '';
-        }
-
-        return "\"{$this->getDatabase()}\".";
-    }
+        $values = $query->getValues();
+        $vectorArrayRaw = $values[0] ?? [];
+        $vectorArray = \is_array($vectorArrayRaw) ? $vectorArrayRaw : [];
+        $vector = \json_encode(\array_map(fn (mixed $v): float => \is_numeric($v) ? (float) $v : 0.0, $vectorArray));
+        $binds[":vector_{$placeholder}"] = $vector;
 
-    /**
-     * Get PDO Type
-     *
-     * @param mixed $value
-     *
-     * @return int
-     * @throws DatabaseException
-     */
-    protected function getPDOType(mixed $value): int
-    {
-        return match (\gettype($value)) {
-            'string', 'double' => PDO::PARAM_STR,
-            'boolean' => PDO::PARAM_BOOL,
-            'integer' => PDO::PARAM_INT,
-            'NULL' => PDO::PARAM_NULL,
-            default => throw new DatabaseException('Unknown PDO Type for ' . \gettype($value)),
+        return match ($query->getMethod()) {
+            Method::VectorDot => "({$alias}.{$attribute} <#> :vector_{$placeholder}::vector)",
+            Method::VectorCosine => "({$alias}.{$attribute} <=> :vector_{$placeholder}::vector)",
+            Method::VectorEuclidean => "({$alias}.{$attribute} <-> :vector_{$placeholder}::vector)",
+            default => null,
         };
     }
 
     /**
-     * Get the SQL function for random ordering
-     *
-     * @return string
-     */
-    protected function getRandomOrder(): string
-    {
-        return 'RANDOM()';
-    }
-
-    /**
-     * Size of POINT spatial type
-     *
-     * @return int
-    */
-    protected function getMaxPointSize(): int
-    {
-        // https://stackoverflow.com/questions/30455025/size-of-data-type-geographypoint-4326-in-postgis
-        return 32;
-    }
-
-
-    /**
-     * Encode array
-     *
-     * @param string $value
-     *
-     * @return array<string>
-     */
-    protected function encodeArray(string $value): array
-    {
-        $string = substr($value, 1, -1);
-        if (empty($string)) {
-            return [];
-        } else {
-            return explode(',', $string);
-        }
-    }
-
-    /**
-     * Decode array
-     *
-     * @param array<string> $value
-     *
-     * @return string
-     */
-    protected function decodeArray(array $value): string
-    {
-        if (empty($value)) {
-            return '{}';
-        }
-
-        foreach ($value as &$item) {
-            $item = '"' . str_replace(['"', '(', ')'], ['\"', '\(', '\)'], $item) . '"';
-        }
-
-        return '{' . implode(",", $value) . '}';
-    }
-
-    public function getMinDateTime(): \DateTime
-    {
-        return new \DateTime('-4713-01-01 00:00:00');
-    }
-
-    /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Are timeouts supported?
-     *
-     * @return bool
-     */
-    public function getSupportForTimeouts(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Does the adapter handle Query Array Overlaps?
-     *
-     * @return bool
-     */
-    public function getSupportForJSONOverlaps(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return false; // Postgres has native boolean type
-    }
-
-    /**
-     * Is get schema attributes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUpserts(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is vector type supported?
-     *
-     * @return bool
-     */
-    public function getSupportForVectors(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForPCRERegex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForPOSIXRegex(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForTrigramIndex(): bool
-    {
-        return true;
-    }
-
-    /**
-     * @return string
+     * {@inheritDoc}
      */
-    public function getLikeOperator(): string
+    protected function getVectorOrderRaw(Query $query, string $alias): ?array
     {
-        return 'ILIKE';
-    }
-
-    /**
-     * @return string
-     */
-    public function getRegexOperator(): string
-    {
-        return '~';
-    }
-
-    protected function processException(PDOException $e): \Exception
-    {
-        // Timeout
-        if ($e->getCode() === '57014' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new TimeoutException('Query timed out', $e->getCode(), $e);
-        }
-
-        // Duplicate table
-        if ($e->getCode() === '42P07' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new DuplicateException('Collection already exists', $e->getCode(), $e);
-        }
-
-        // Duplicate column
-        if ($e->getCode() === '42701' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
-        }
-
-        // Duplicate row
-        if ($e->getCode() === '23505' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            $columns = $this->getViolatedColumns($e->getMessage());
-            if ($columns !== null && $columns !== ['_uid'] && $columns !== ['_tenant', '_uid']) {
-                return new UniqueException('Unique index violation', $e->getCode(), $e);
-            }
-            return new DuplicateException('Document already exists', $e->getCode(), $e);
-        }
-
-        // Data is too big for column resize
-        if ($e->getCode() === '22001' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new TruncateException('Resize would result in data truncation', $e->getCode(), $e);
-        }
-
-        // Numeric value out of range (overflow/underflow from operators)
-        if ($e->getCode() === '22003' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new LimitException('Numeric value out of range', $e->getCode(), $e);
-        }
-
-        // Invalid argument for power function (e.g. 0 to a negative power, or a negative base to a
-        // fractional exponent) — matches MariaDB, which reports the same as a numeric range error.
-        if ($e->getCode() === '2201F' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new LimitException('Value out of range', $e->getCode(), $e);
-        }
-
-        // Datetime field overflow
-        if ($e->getCode() === '22008' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new LimitException('Datetime field overflow', $e->getCode(), $e);
-        }
-
-        // Unknown table
-        if ($e->getCode() === '42P01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new NotFoundException('Collection not found', $e->getCode(), $e);
-        }
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        // Unknown column
-        if ($e->getCode() === "42703" && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new NotFoundException('Attribute not found', $e->getCode(), $e);
-        }
+        $attribute = $this->filter($query->getAttribute());
+        $attribute = $this->quote($attribute);
+        $quotedAlias = $this->quote($alias);
 
-        return $e;
-    }
+        $values = $query->getValues();
+        $vectorArrayRaw2 = $values[0] ?? [];
+        $vectorArray2 = \is_array($vectorArrayRaw2) ? $vectorArrayRaw2 : [];
+        $vector = \json_encode(\array_map(fn (mixed $v): float => \is_numeric($v) ? (float) $v : 0.0, $vectorArray2));
+
+        $expression = match ($query->getMethod()) {
+            Method::VectorDot => "({$quotedAlias}.{$attribute} <#> ?::vector)",
+            Method::VectorCosine => "({$quotedAlias}.{$attribute} <=> ?::vector)",
+            Method::VectorEuclidean => "({$quotedAlias}.{$attribute} <-> ?::vector)",
+            default => null,
+        };
 
-    /**
-     * Extract the violated columns from a unique violation error, e.g.
-     * "DETAIL:  Key (_uid, _tenant)=(movie, 1) already exists." resolves to
-     * ['_tenant', '_uid']. Returns null when the message cannot be parsed.
-     *
-     * @return array<string>|null
-     */
-    protected function getViolatedColumns(string $message): ?array
-    {
-        if (\preg_match('/Key \(([^)]+)\)=/', $message, $matches) !== 1) {
+        if ($expression === null) {
             return null;
         }
 
-        $columns = \array_map(
-            fn (string $column) => \trim($column, " \t\"'"),
-            \explode(',', $matches[1])
-        );
-
-        \sort($columns);
-
-        return $columns;
-    }
-
-    /**
-     * @param string $string
-     * @return string
-     */
-    protected function quote(string $string): string
-    {
-        return "\"{$string}\"";
-    }
-
-    /**
-     * Is spatial attributes supported?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Are object (JSONB) attributes supported?
-     *
-     * @return bool
-    */
-    public function getSupportForObject(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Are object (JSONB) indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForObjectIndexes(): bool
-    {
-        return true;
+        return ['expression' => $expression, 'bindings' => [$vector]];
     }
 
-    /**
-     * Does the adapter support null values in spatial indexes?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Does the adapter includes boundary during spatial contains?
-     *
-     * @return bool
-    */
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Does the adapter support order attribute in spatial indexes?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
-     *
-     * @return bool
-     */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
+    #[\Override]
+    protected function getSQLReadableDistance(string $distance): string
     {
-        return false;
+        return "{$distance}::text";
     }
 
     /**
-     * Adapter supports optional spatial attributes with existing rows.
+     * Match read permissions against the JSONB copy stored on each row. This
+     * keeps PostgreSQL free to combine the GIN permission index with ordering
+     * indexes instead of resolving a permissions-table semi-join first.
      *
-     * @return bool
+     * @param  array<string>  $roles
      */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
-    }
-
-    protected function getInsertKeyword(): string
-    {
-        return 'INSERT INTO';
-    }
-
-    protected function getInsertSuffix(string $table): string
-    {
-        if (!$this->skipDuplicates) {
-            return '';
-        }
-
-        $conflictTarget = $this->sharedTables ? '("_uid", "_tenant")' : '("_uid")';
-
-        return "ON CONFLICT {$conflictTarget} DO NOTHING";
-    }
-
-    protected function getInsertPermissionsSuffix(): string
-    {
-        if (!$this->skipDuplicates) {
-            return '';
-        }
-
-        $conflictTarget = $this->sharedTables
-            ? '("_type", "_permission", "_document", "_tenant")'
-            : '("_type", "_permission", "_document")';
-
-        return "ON CONFLICT {$conflictTarget} DO NOTHING";
-    }
-
-    public function decodePoint(string $wkb): array
-    {
-        if (str_starts_with(strtoupper($wkb), 'POINT(')) {
-            $start = strpos($wkb, '(') + 1;
-            $end = strrpos($wkb, ')');
-            $inside = substr($wkb, $start, $end - $start);
-
-            $coords = explode(' ', trim($inside));
-            return [(float)$coords[0], (float)$coords[1]];
-        }
-
-        $bin = hex2bin($wkb);
-        if ($bin === false) {
-            throw new DatabaseException('Invalid hex WKB string');
-        }
-
-        if (strlen($bin) < 13) { // 1 byte endian + 4 bytes type + 8 bytes for X
-            throw new DatabaseException('WKB too short');
-        }
-
-        $isLE = ord($bin[0]) === 1;
-
-        // Type (4 bytes)
-        $typeBytes = substr($bin, 1, 4);
-        if (strlen($typeBytes) !== 4) {
-            throw new DatabaseException('Failed to extract type bytes from WKB');
-        }
-
-        $typeArr = unpack($isLE ? 'V' : 'N', $typeBytes);
-        if ($typeArr === false || !isset($typeArr[1])) {
-            throw new DatabaseException('Failed to unpack type from WKB');
-        }
-        $type = $typeArr[1];
-
-        // Offset to coordinates (skip SRID if present)
-        $offset = 5 + (($type & 0x20000000) ? 4 : 0);
-
-        if (strlen($bin) < $offset + 16) { // 16 bytes for X,Y
-            throw new DatabaseException('WKB too short for coordinates');
-        }
-
-        $fmt = $isLE ? 'e' : 'E'; // little vs big endian double
-
-        // X coordinate
-        $xArr = unpack($fmt, substr($bin, $offset, 8));
-        if ($xArr === false || !isset($xArr[1])) {
-            throw new DatabaseException('Failed to unpack X coordinate');
-        }
-        $x = (float)$xArr[1];
-
-        // Y coordinate
-        $yArr = unpack($fmt, substr($bin, $offset + 8, 8));
-        if ($yArr === false || !isset($yArr[1])) {
-            throw new DatabaseException('Failed to unpack Y coordinate');
-        }
-        $y = (float)$yArr[1];
-
-        return [$x, $y];
-    }
-
-    public function decodeLinestring(mixed $wkb): array
-    {
-        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
-            $start = strpos($wkb, '(') + 1;
-            $end = strrpos($wkb, ')');
-            $inside = substr($wkb, $start, $end - $start);
-
-            $points = explode(',', $inside);
-            return array_map(function ($point) {
-                $coords = explode(' ', trim($point));
-                return [(float)$coords[0], (float)$coords[1]];
-            }, $points);
-        }
-
-        if (ctype_xdigit($wkb)) {
-            $wkb = hex2bin($wkb);
-            if ($wkb === false) {
-                throw new DatabaseException("Failed to convert hex WKB to binary.");
-            }
-        }
-
-        if (strlen($wkb) < 9) {
-            throw new DatabaseException("WKB too short to be a valid geometry");
-        }
-
-        $byteOrder = ord($wkb[0]);
-        if ($byteOrder === 0) {
-            throw new DatabaseException("Big-endian WKB not supported");
-        } elseif ($byteOrder !== 1) {
-            throw new DatabaseException("Invalid byte order in WKB");
-        }
-
-        // Type + SRID flag
-        $typeField = unpack('V', substr($wkb, 1, 4));
-        if ($typeField === false) {
-            throw new DatabaseException('Failed to unpack the type field from WKB.');
-        }
-
-        $typeField = $typeField[1];
-        $geomType = $typeField & 0xFF;
-        $hasSRID = ($typeField & 0x20000000) !== 0;
-
-        if ($geomType !== 2) { // 2 = LINESTRING
-            throw new DatabaseException("Not a LINESTRING geometry type, got {$geomType}");
-        }
-
-        $offset = 5;
-        if ($hasSRID) {
-            $offset += 4;
-        }
-
-        $numPoints = unpack('V', substr($wkb, $offset, 4));
-        if ($numPoints === false) {
-            throw new DatabaseException("Failed to unpack number of points at offset {$offset}.");
-        }
-
-        $numPoints = $numPoints[1];
-        $offset += 4;
-
-        $points = [];
-        for ($i = 0; $i < $numPoints; $i++) {
-            $x = unpack('e', substr($wkb, $offset, 8));
-            if ($x === false) {
-                throw new DatabaseException("Failed to unpack X coordinate at offset {$offset}.");
+    #[\Override]
+    protected function newPermissionHook(string $collection, array $roles, string $type = PermissionType::Read->value, string $documentColumn = Storage::UID): PermissionFilter
+    {
+        return new class (\array_values($roles), $type, $documentColumn) extends PermissionFilter {
+            /**
+             * @param  list<string>  $roles
+             */
+            public function __construct(array $roles, string $type, string $documentColumn)
+            {
+                parent::__construct(
+                    roles: $roles,
+                    permissionsTable: static fn (string $table): string => $table,
+                    type: $type,
+                    documentColumn: $documentColumn,
+                    quoteChar: '"',
+                );
             }
 
-            $x = (float) $x[1];
+            #[\Override]
+            public function filter(string $table): Condition
+            {
+                if (empty($this->roles)) {
+                    return new Condition('1 = 0');
+                }
 
-            $offset += 8;
+                $parts = \explode('.', $this->documentColumn);
+                $parts[\array_key_last($parts)] = Storage::PERMISSIONS;
+                $column = \implode('.', \array_map(
+                    static fn (string $part): string => '"'.\str_replace('"', '""', $part).'"',
+                    $parts
+                ));
 
-            $y = unpack('e', substr($wkb, $offset, 8));
-            if ($y === false) {
-                throw new DatabaseException("Failed to unpack Y coordinate at offset {$offset}.");
+                $conditions = [];
+                $bindings = [];
+                foreach ($this->roles as $role) {
+                    $conditions[] = "{$column} @> ?::jsonb";
+                    $bindings[] = \json_encode(["{$this->type}(\"{$role}\")"]) ?: '[]';
+                }
+
+                return new Condition('('.\implode(' OR ', $conditions).')', $bindings);
             }
+        };
+    }
 
-            $y = (float) $y[1];
+    /**
+     * Size of POINT spatial type
+     */
+    protected function getMaxPointSize(): int
+    {
+        // https://stackoverflow.com/questions/30455025/size-of-data-type-geographypoint-4326-in-postgis
+        return 32;
+    }
 
-            $offset += 8;
-            $points[] = [$x, $y];
-        }
+    protected function getSearchRelevanceRaw(Query $query, string $alias): ?array
+    {
+        [$quotedAlias, $quotedAttribute] = $this->quoteSearchAttribute($query->getAttribute(), $alias);
+        $column = $quotedAlias.'.'.$quotedAttribute;
+        $searchVal = $query->getValue();
+        $term = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
 
-        return $points;
+        return [
+            'expression' => "ts_rank(to_tsvector(regexp_replace({$column}, '[^\w]+',' ','g')), websearch_to_tsquery(?)) AS \"_relevance\"",
+            'order' => '"_relevance" DESC',
+            'bindings' => [$term],
+        ];
     }
 
-    public function decodePolygon(string $wkb): array
+    protected function processException(PDOException $e): Exception
     {
-        // POLYGON((x1,y1),(x2,y2))
-        if (str_starts_with($wkb, 'POLYGON((')) {
-            $start = strpos($wkb, '((') + 2;
-            $end = strrpos($wkb, '))');
-            $inside = substr($wkb, $start, $end - $start);
+        // Timeout
+        if ($e->getCode() === '57014' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        }
 
-            $rings = explode('),(', $inside);
-            return array_map(function ($ring) {
-                $points = explode(',', $ring);
-                return array_map(function ($point) {
-                    $coords = explode(' ', trim($point));
-                    return [(float)$coords[0], (float)$coords[1]];
-                }, $points);
-            }, $rings);
+        // Duplicate table
+        if ($e->getCode() === '42P07' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
         }
 
-        // Convert hex string to binary if needed
-        if (preg_match('/^[0-9a-fA-F]+$/', $wkb)) {
-            $wkb = hex2bin($wkb);
-            if ($wkb === false) {
-                throw new DatabaseException("Invalid hex WKB");
+        // Duplicate column
+        if ($e->getCode() === '42701' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
+        }
+
+        // Duplicate row
+        if ($e->getCode() === '23505' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            $columns = $this->getViolatedColumns($e->getMessage());
+            if ($columns !== null && $columns !== [Storage::UID] && $columns !== [Storage::TENANT, Storage::UID]) {
+                return new UniqueException('Unique index violation', $e->getCode(), $e);
             }
+
+            return new DuplicateException('Document already exists', $e->getCode(), $e);
         }
 
-        if (strlen($wkb) < 9) {
-            throw new DatabaseException("WKB too short");
+        // Data is too big for column resize
+        if ($e->getCode() === '22001' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new TruncateException('Resize would result in data truncation', $e->getCode(), $e);
         }
 
-        $uInt32 = 'V'; // little-endian 32-bit unsigned
-        $uDouble = 'd'; // little-endian double
+        // Numeric value out of range (overflow/underflow from operators)
+        if ($e->getCode() === '22003' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new LimitException('Numeric value out of range', $e->getCode(), $e);
+        }
 
-        $typeInt = unpack($uInt32, substr($wkb, 1, 4));
-        if ($typeInt === false) {
-            throw new DatabaseException('Failed to unpack type field from WKB.');
+        // Invalid argument for power function
+        if ($e->getCode() === '2201F' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new LimitException('Invalid argument for power function', $e->getCode(), $e);
         }
 
-        $typeInt = (int) $typeInt[1];
-        $hasSrid = ($typeInt & 0x20000000) !== 0;
-        $geomType = $typeInt & 0xFF;
+        // Datetime field overflow
+        if ($e->getCode() === '22008' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new LimitException('Datetime field overflow', $e->getCode(), $e);
+        }
 
-        if ($geomType !== 3) { // 3 = POLYGON
-            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
+        // Unknown table
+        if ($e->getCode() === '42P01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new NotFoundException('Collection not found', $e->getCode(), $e);
         }
 
-        $offset = 5;
-        if ($hasSrid) {
-            $offset += 4;
+        // Unknown column
+        if ($e->getCode() === '42703' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new NotFoundException('Attribute not found', $e->getCode(), $e);
         }
 
-        // Number of rings
-        $numRings = unpack($uInt32, substr($wkb, $offset, 4));
-        if ($numRings === false) {
-            throw new DatabaseException('Failed to unpack number of rings from WKB.');
+        return $e;
+    }
+
+    /**
+     * Extract the columns named by a PostgreSQL unique-violation DETAIL line.
+     *
+     * @return list<string>|null
+     */
+    protected function getViolatedColumns(string $message): ?array
+    {
+        if (\preg_match('/Key \(([^)]+)\)=/', $message, $matches) !== 1) {
+            return null;
         }
 
-        $numRings = (int) $numRings[1];
-        $offset += 4;
+        $columns = \array_map(
+            static fn (string $column): string => \trim($column, " \t\"'"),
+            \explode(',', $matches[1])
+        );
 
-        $rings = [];
-        for ($r = 0; $r < $numRings; $r++) {
-            $numPoints = unpack($uInt32, substr($wkb, $offset, 4));
-            if ($numPoints === false) {
-                throw new DatabaseException('Failed to unpack number of points from WKB.');
-            }
+        \sort($columns);
 
-            $numPoints = (int) $numPoints[1];
-            $offset += 4;
-            $points = [];
-            for ($i = 0; $i < $numPoints; $i++) {
-                $x = unpack($uDouble, substr($wkb, $offset, 8));
-                if ($x === false) {
-                    throw new DatabaseException('Failed to unpack X coordinate from WKB.');
-                }
+        return $columns;
+    }
 
-                $x = (float) $x[1];
+    protected function quote(string $string): string
+    {
+        return "\"{$string}\"";
+    }
 
-                $y = unpack($uDouble, substr($wkb, $offset + 8, 8));
-                if ($y === false) {
-                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
-                }
+    protected function getIdentifierQuoteChar(): string
+    {
+        return '"';
+    }
+
+    protected function getInsertSuffix(string $table): string
+    {
+        if (! $this->skipDuplicates) {
+            return '';
+        }
 
-                $y = (float) $y[1];
+        $conflictTarget = $this->sharedTables
+            ? '("'.Storage::UID.'", "'.Storage::TENANT.'")'
+            : '("'.Storage::UID.'")';
 
-                $points[] = [$x, $y];
-                $offset += 16;
-            }
-            $rings[] = $points;
+        return "ON CONFLICT {$conflictTarget} DO NOTHING";
+    }
+
+    protected function getInsertPermissionsSuffix(): string
+    {
+        if (! $this->skipDuplicates) {
+            return '';
         }
 
-        return $rings; // array of rings, each ring is array of [x,y]
+        $conflictTarget = $this->sharedTables
+            ? '("'.Storage::PERM_TYPE.'", "'.Storage::PERM_PERMISSION.'", "'.Storage::PERM_DOCUMENT.'", "'.Storage::TENANT.'")'
+            : '("'.Storage::PERM_TYPE.'", "'.Storage::PERM_PERMISSION.'", "'.Storage::PERM_DOCUMENT.'")';
+
+        return "ON CONFLICT {$conflictTarget} DO NOTHING";
     }
 
+
     /**
      * Get SQL expression for operator
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param array<string, mixed> $binds
-     * @param bool $useTargetPrefix
-     * @return ?string
      */
-    protected function getOperatorSQL(string $column, Operator $operator, array &$binds, bool $useTargetPrefix = false): ?string
+    protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex, bool $useTargetPrefix = false): ?string
     {
         $quotedColumn = $this->quote($column);
         $columnRef = $useTargetPrefix ? "target.{$quotedColumn}" : $quotedColumn;
@@ -2618,138 +2012,160 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Increment:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) + CAST(:$bindKey AS NUMERIC) > CAST(:$maxKey AS NUMERIC) THEN COALESCE({$columnRef}, 0)
                         ELSE COALESCE({$columnRef}, 0) + CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Decrement:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) - CAST(:$bindKey AS NUMERIC) < CAST(:$minKey AS NUMERIC) THEN COALESCE({$columnRef}, 0)
                         ELSE COALESCE({$columnRef}, 0) - CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Multiply:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) * CAST(:$bindKey AS NUMERIC) > CAST(:$maxKey AS NUMERIC) THEN COALESCE({$columnRef}, 0)
                         ELSE COALESCE({$columnRef}, 0) * CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Divide:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN CAST(:$bindKey AS NUMERIC) != 0 AND COALESCE({$columnRef}, 0) / CAST(:$bindKey AS NUMERIC) < CAST(:$minKey AS NUMERIC) THEN COALESCE({$columnRef}, 0)
                         ELSE COALESCE({$columnRef}, 0) / CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Modulo:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = MOD(COALESCE({$columnRef}::numeric, 0), :$bindKey::numeric)";
 
-            case Operator::TYPE_POWER:
+            case OperatorType::Power:
                 $exponent = $values[0] ?? 1;
-                $bindKey = $this->registerOperatorBind($binds, $exponent);
+                if (! \is_int($exponent) && ! \is_float($exponent)) {
+                    throw new OperatorException('Power exponent must be numeric');
+                }
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
-                    $col = "COALESCE({$columnRef}, 0)";
-
-                    // Leave the value unchanged only for undefined inputs, then apply the power if
-                    // the result stays within the max. The exponent is constant, so only the
-                    // undefined guard its value can actually trigger is emitted. PostgreSQL throws
-                    // a hard error for 0 to a negative power and a negative base to a fractional
-                    // exponent, so those must never reach POWER().
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
+                    $columnValue = "COALESCE({$columnRef}, 0)";
                     $oddInteger = \floor($exponent) == $exponent && ((int) $exponent) % 2 !== 0;
+                    $guards = [];
 
-                    $whens = [];
                     if ($exponent < 0) {
-                        $whens[] = "WHEN {$col} = 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} = 0 THEN {$columnValue}";
                     }
                     if (\floor($exponent) != $exponent) {
-                        $whens[] = "WHEN {$col} < 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} < 0 THEN {$columnValue}";
                     }
-                    // Cap by magnitude via logarithms so POWER() never runs on a value that would
-                    // overflow (base^exp > max  <=>  exp * LN(base) > LN(max)).
                     if ($exponent == 0) {
-                        // Every base to the zeroth power is 1 (including 0^0), which the magnitude
-                        // check below can't see for a base of 0. The result 1 exceeds the max when
-                        // max < 1, i.e. LN(max) < 0 (LN also coerces the bound value numerically).
-                        $whens[] = "WHEN LN(:$maxKey) < 0 THEN {$col}";
+                        $guards[] = "WHEN LN(:$maxKey) < 0 THEN {$columnValue}";
                     } elseif ($oddInteger) {
-                        // An odd exponent keeps a negative base negative, and a negative result is
-                        // always within a positive max, so only cap positive bases; negative bases
-                        // fall through to POWER() and their (negative) result is applied.
-                        $whens[] = "WHEN {$col} > 0 AND :$bindKey * LN({$col}) > LN(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} > 0 AND :$bindKey * LN({$columnValue}) > LN(:$maxKey) THEN {$columnValue}";
                     } else {
-                        // Otherwise the result is non-negative, so its magnitude equals its value —
-                        // cap either sign. ABS() keeps LN() defined for a negative even-power base.
-                        $whens[] = "WHEN {$col} <> 0 AND :$bindKey * LN(ABS({$col})) > LN(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} <> 0 AND :$bindKey * LN(ABS({$columnValue})) > LN(:$maxKey) THEN {$columnValue}";
                     }
 
-                    $whenSql = \implode(' ', $whens);
-                    return "{$quotedColumn} = CASE {$whenSql} ELSE POWER({$col}, :$bindKey) END";
+                    return "{$quotedColumn} = CASE ".\implode(' ', $guards)." ELSE POWER({$columnValue}, :$bindKey) END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$columnRef}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? '');
+            case OperatorType::StringConcat:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = CONCAT(COALESCE({$columnRef}, ''), :$bindKey)";
 
-            case Operator::TYPE_STRING_REPLACE:
-                $searchKey = $this->registerOperatorBind($binds, $values[0] ?? '');
-                $replaceKey = $this->registerOperatorBind($binds, $values[1] ?? '');
+            case OperatorType::StringReplace:
+                $searchKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $replaceKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = REPLACE(COALESCE({$columnRef}, ''), :$searchKey, :$replaceKey)";
 
                 // Boolean operators
-            case Operator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 return "{$quotedColumn} = NOT COALESCE({$columnRef}, FALSE)";
 
                 // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayAppend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, '[]'::jsonb) || :$bindKey::jsonb";
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayPrepend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = :$bindKey::jsonb || COALESCE({$columnRef}, '[]'::jsonb)";
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 return "{$quotedColumn} = COALESCE((
                     SELECT jsonb_agg(DISTINCT value)
                     FROM jsonb_array_elements({$columnRef}) AS value
                 ), '[]'::jsonb)";
 
-            case Operator::TYPE_ARRAY_REMOVE:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values[0] ?? null));
+            case OperatorType::ArrayRemove:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE((
                     SELECT jsonb_agg(value)
                     FROM jsonb_array_elements({$columnRef}) AS value
                     WHERE value != :$bindKey::jsonb
                 ), '[]'::jsonb)";
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $indexKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
-                $valueKey = $this->registerOperatorBind($binds, json_encode($values[1] ?? null));
+            case OperatorType::ArrayInsert:
+                $indexKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = (
                     SELECT jsonb_agg(value ORDER BY idx)
                     FROM (
@@ -2765,27 +2181,32 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     ) AS combined
                 )";
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayIntersect:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE((
                     SELECT jsonb_agg(value)
                     FROM jsonb_array_elements({$columnRef}) AS value
                     WHERE value IN (SELECT jsonb_array_elements(:$bindKey::jsonb))
                 ), '[]'::jsonb)";
 
-            case Operator::TYPE_ARRAY_DIFF:
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayDiff:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE((
                     SELECT jsonb_agg(value)
                     FROM jsonb_array_elements({$columnRef}) AS value
                     WHERE value NOT IN (SELECT jsonb_array_elements(:$bindKey::jsonb))
                 ), '[]'::jsonb)";
 
-            case Operator::TYPE_ARRAY_FILTER:
-                $condition = $values[0] ?? 'equal';
-                $filterValue = $values[1] ?? null;
-                $conditionKey = $this->registerOperatorBind($binds, $condition);
-                $valueKey = $this->registerOperatorBind($binds, $filterValue === null ? null : json_encode($filterValue));
+            case OperatorType::ArrayFilter:
+                $conditionKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE((
                     SELECT jsonb_agg(value)
                     FROM jsonb_array_elements({$columnRef}) AS value
@@ -2803,32 +2224,135 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                 ), '[]'::jsonb)";
 
                 // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateAddDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = {$columnRef} + (:$bindKey || ' days')::INTERVAL";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateSubDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = {$columnRef} - (:$bindKey || ' days')::INTERVAL";
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return "{$quotedColumn} = NOW()";
 
             default:
-                throw new OperatorException("Invalid operator: {$method}");
+                throw new OperatorException('Invalid operator');
+        }
+    }
+
+    /**
+     * Bind operator parameters to statement
+     * Override to handle PostgreSQL-specific JSON binding
+     */
+    protected function bindOperatorParams(PDOStatement|DatabasePDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
+    {
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+
+        switch ($method) {
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                $arrayValue = json_encode($values);
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::ArrayRemove:
+                $value = $values[0] ?? null;
+                $bindKey = "op_{$bindIndex}";
+                // Always JSON encode for PostgreSQL jsonb comparison
+                $stmt->bindValue(':'.$bindKey, json_encode($value), PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                $arrayValue = json_encode($values);
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            default:
+                // Use parent implementation for other operators
+                parent::bindOperatorParams($stmt, $operator, $bindIndex);
+                break;
+        }
+    }
+
+    protected function getFulltextValue(string $value): string
+    {
+        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
+
+        /** Keep only unicode letters, numbers, underscores, and whitespace. */
+        $value = preg_replace('/[^\p{L}\p{N}_\s]/u', ' ', $value) ?? '';
+        $value = preg_replace('/\s+/', ' ', $value) ?? '';
+        $value = trim($value);
+
+        if (! $exact) {
+            $value = str_replace(' ', ' or ', $value);
         }
+
+        return "'".$value."'";
     }
 
-    public function getSupportNonUtfCharacters(): bool
+    protected function getOperatorBuilderExpression(string $column, Operator $operator): array
     {
-        return false;
+        if ($operator->getMethod() === OperatorType::ArrayRemove) {
+            $result = parent::getOperatorBuilderExpression($column, $operator);
+            $values = $operator->getValues();
+            $value = $values[0] ?? null;
+            if (! is_array($value)) {
+                $result['bindings'] = [json_encode($value)];
+            }
+
+            return $result;
+        }
+
+        return parent::getOperatorBuilderExpression($column, $operator);
     }
 
     /**
-     * Ensure index key length stays within PostgreSQL's 63 character limit.
+     * Encode array
      *
-     * @param string $key
-     * @return string
+     *
+     * @return array<string>
+     */
+    protected function encodeArray(string $value): array
+    {
+        $string = substr($value, 1, -1);
+        if (empty($string)) {
+            return [];
+        } else {
+            return explode(',', $string);
+        }
+    }
+
+    /**
+     * Decode array
+     *
+     * @param  array<string>  $value
+     */
+    protected function decodeArray(array $value): string
+    {
+        if (empty($value)) {
+            return '{}';
+        }
+
+        foreach ($value as &$item) {
+            $item = '"'.str_replace(['"', '(', ')'], ['\"', '\(', '\)'], $item).'"';
+        }
+
+        return '{'.implode(',', $value).'}';
+    }
+
+    /**
+     * Ensure index key length stays within PostgreSQL's 63 character limit.
      */
     protected function getShortKey(string $key): string
     {
@@ -2854,29 +2378,35 @@ protected function getShortKey(string $key): string
         return substr($hash, 0, self::MAX_IDENTIFIER_NAME);
     }
 
-    protected function getSQLTable(string $name): string
+    protected function getPhysicalTableName(string $name): string
     {
-        $table = "{$this->getNamespace()}_{$this->filter($name)}";
-        $table = $this->getShortKey($table);
+        return $this->getShortKey("{$this->getNamespace()}_{$this->filter($name)}");
+    }
 
-        return "{$this->quote($this->getDatabase())}.{$this->quote($table)}";
+    #[\Override]
+    protected function getSQLTable(string $name): string
+    {
+        return "{$this->quote($this->getDatabase())}.{$this->quote($this->getPhysicalTableName($name))}";
     }
 
-    public function getSupportForTTLIndexes(): bool
+    #[\Override]
+    protected function getSQLTableRaw(string $name): string
     {
-        return false;
+        return $this->getDatabase().'.'.$this->getPhysicalTableName($name);
     }
+
     protected function buildJsonbPath(string $path, bool $asText = false): string
     {
         $parts = \explode('.', $path);
 
         foreach ($parts as $part) {
-            if (!preg_match('/^[a-zA-Z0-9_\-]+$/', $part)) {
-                throw new DatabaseException('Invalid JSON key ' . $part);
+            if (! preg_match('/^[a-zA-Z0-9_\-]+$/', $part)) {
+                throw new DatabaseException('Invalid JSON key '.$part);
             }
         }
         if (\count($parts) === 1) {
             $column = $this->filter($parts[0]);
+
             return $this->quote($column);
         }
 
diff --git a/src/Database/Adapter/ReadWritePool.php b/src/Database/Adapter/ReadWritePool.php
new file mode 100644
index 0000000000..408d6f5cad
--- /dev/null
+++ b/src/Database/Adapter/ReadWritePool.php
@@ -0,0 +1,164 @@
+<?php
+
+namespace Utopia\Database\Adapter;
+
+use Utopia\Database\Adapter;
+use Utopia\Pools\Pool as UtopiaPool;
+
+class ReadWritePool extends Pool
+{
+    private const READ_METHODS = [
+        'find',
+        'getDocument',
+        'count',
+        'sum',
+        'exists',
+        'list',
+        'getSchemaAttributes',
+        'getSchemaIndexes',
+        'getBuilder',
+        'getSchema',
+        'rawQuery',
+        'getColumnType',
+        'decodePoint',
+        'decodeLinestring',
+        'decodePolygon',
+        'getSizeOfCollection',
+        'getSizeOfCollectionOnDisk',
+        'ping',
+        'getConnectionId',
+        'getDocumentSizeLimit',
+        'getAttributeWidth',
+        'getCountOfAttributes',
+        'getCountOfIndexes',
+        'getCountOfDefaultAttributes',
+        'getCountOfDefaultIndexes',
+        'getLimitForString',
+        'getLimitForInt',
+        'getLimitForBigInt',
+        'getLimitForAttributes',
+        'getLimitForIndexes',
+        'getMaxIndexLength',
+        'getMaxVarcharLength',
+        'getMaxUIDLength',
+        'getMinDateTime',
+        'getIdAttributeType',
+        'getKeywords',
+        'getInternalIndexesKeys',
+        'supports',
+        'capabilities',
+        'hasFeature',
+    ];
+
+    /**
+     * @var UtopiaPool<covariant Adapter>
+     */
+    private UtopiaPool $readPool;
+
+    private bool $sticky = true;
+
+    private int $stickyDurationMs = 5000;
+
+    private ?float $lastWriteTimestamp = null;
+
+    /**
+     * @param  UtopiaPool<covariant Adapter>  $writePool
+     * @param  UtopiaPool<covariant Adapter>  $readPool
+     */
+    public function __construct(UtopiaPool $writePool, UtopiaPool $readPool)
+    {
+        parent::__construct($writePool);
+        $this->readPool = $readPool;
+    }
+
+    public function setStickyDuration(int $milliseconds): static
+    {
+        $this->stickyDurationMs = $milliseconds;
+
+        return $this;
+    }
+
+    public function setSticky(bool $sticky): static
+    {
+        $this->sticky = $sticky;
+
+        return $this;
+    }
+
+    public function delegate(string $method, array $args): mixed
+    {
+        return $this->borrowAndInvoke($method, $args);
+    }
+
+    /**
+     * @param  array<mixed>  $args
+     * @param  class-string|null  $feature
+     */
+    protected function borrowAndInvoke(string $method, array $args, ?string $feature = null): mixed
+    {
+        if ($this->pinnedAdapter !== null) {
+            $adapter = $this->pinnedAdapter;
+            $this->syncBorrowedAdapter($adapter);
+
+            return $this->invokeDelegated($adapter, $method, $args, $feature);
+        }
+
+        if ($this->isReadOperation($method) && ! $this->isSticky()) {
+            return $this->readPool->use(function (Adapter $adapter) use ($method, $args, $feature) {
+                $this->syncConfig($adapter);
+
+                return $this->invokeDelegated($adapter, $method, $args, $feature);
+            });
+        }
+
+        if (! $this->isReadOperation($method)) {
+            $this->lastWriteTimestamp = \microtime(true);
+        }
+
+        return parent::borrowAndInvoke($method, $args, $feature);
+    }
+
+    private function isReadOperation(string $method): bool
+    {
+        return \in_array($method, self::READ_METHODS, true);
+    }
+
+    private function isSticky(): bool
+    {
+        if (! $this->sticky || $this->lastWriteTimestamp === null) {
+            return false;
+        }
+
+        $elapsed = (\microtime(true) - $this->lastWriteTimestamp) * 1000;
+
+        return $elapsed < $this->stickyDurationMs;
+    }
+
+    private function syncConfig(Adapter $adapter): void
+    {
+        $adapter->setDatabase($this->getDatabase());
+        $adapter->setNamespace($this->getNamespace());
+        $adapter->setSharedTables($this->getSharedTables());
+        $adapter->setTenant($this->getTenant());
+        $adapter->setTenantPerDocument($this->getTenantPerDocument());
+        $adapter->setAuthorization($this->authorization);
+
+        $this->syncTimeouts($adapter);
+
+        $adapter->resetDebug();
+        foreach ($this->getDebug() as $key => $value) {
+            $adapter->setDebug($key, $value);
+        }
+
+        $adapter->resetMetadata();
+        foreach ($this->getMetadata() as $key => $value) {
+            $adapter->setMetadata($key, $value);
+        }
+
+        $adapter->setProfiler($this->profiler);
+        $adapter->resetTransforms();
+        foreach ($this->queryTransforms as $tName => $tTransform) {
+            $adapter->addTransform($tName, $tTransform);
+        }
+    }
+}
diff --git a/src/Database/Adapter/Redis.php b/src/Database/Adapter/Redis.php
index 81f3350634..7142ffb743 100644
--- a/src/Database/Adapter/Redis.php
+++ b/src/Database/Adapter/Redis.php
@@ -6,6 +6,8 @@
 
 use Redis as RedisClient;
 use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -13,69 +15,50 @@
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
-use Utopia\Database\Exception\Operator as OperatorException;
 use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Transaction as TransactionException;
-use Utopia\Database\Exception\Unique as UniqueException;
 use Utopia\Database\Helpers\ID;
-use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Method;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 /**
  * Redis-backed adapter mirroring the Memory adapter's surface.
  *
  * Storage key schema (every key is prefixed with `KEY_PREFIX:`):
  *
- *     {ns}                      = getNamespace()
- *     {db}                      = current setDatabase() value
- *     {col}                     = collection ID
+ *     {ns}:dbs                                | SET  | database names
+ *     {ns}:{db}:cols                          | SET  | collection IDs
+ *     {ns}:{db}:meta:{col}                    | HASH | schema/attrs/indexes
+ *     {ns}:{db}:doc:{col}:{id}                | STRING | JSON Document
+ *     {ns}:{db}:idx:{col}                     | SET  | doc IDs in collection
+ *     {ns}:{db}:perm:{col}:{letter}:{role}    | SET  | doc IDs by action+role
+ *     {ns}:{db}:perm:doc:{col}:{id}           | HASH | role -> csv letters
  *
- *     Key                                          | Type | Holds
- *     ---------------------------------------------+------+----------------------------------
- *     {ns}:{db}:dbs                                | SET  | database names
- *     {ns}:{db}:cols                               | SET  | collection IDs in this db
- *     {ns}:{db}:meta:{col}                         | HASH | fields: schema, attrs, indexes, docCount, sizeBytes
- *     {ns}:{db}:doc:{col}:{id}                     | STRING | JSON-encoded Document
- *     {ns}:{db}:idx:{col}                          | SET  | doc IDs in collection (for SCAN/list)
- *     {ns}:{db}:perm:{col}:{r|c|u|d|w}:{role}      | SET  | doc IDs by action+role (non-shared)
- *     {ns}:{db}:perm:t:{tenant}:{col}:{letter}:{role} | SET | shared-tables variant
- *     {ns}:{db}:perm:doc:{col}:{id}                | HASH | role -> csv("read,update,delete")
- *     {ns}:{db}:perm:t:{tenant}:doc:{col}:{id}     | HASH | shared-tables variant
- *     {ns}:{db}:tenants:{col}:{tenant}             | SET  | doc IDs filtered by tenant
- *
- * Transaction model: `tx()` is a single-shot wrapper that surfaces
- * `\RedisException` as `TransactionException`. There is NO retry, no
- * `WATCH`/`MULTI`/`EXEC`, and no automatic OCC — retrying would replay
- * journal side-effects (duplicate `INCR` on sequence keys, double
- * pipelined SADDs). Real OCC is a follow-up; `getSupportForTransactionRetries()`
- * returns `false` so the shared trait's OCC tests stay off. Pessimistic
- * update locks are intentionally unsupported.
- *
- * Rollback contract: `rollbackJournal()` MUST use raw `\Redis` client
- * commands only — calling a public adapter method re-enters `journal()`
- * and recurses infinitely. All inverses route through `rawDeleteDoc()`
- * and `rawRestoreDoc()`.
+ * Shared-tables variants bucket on tenant under `t:{tenant}` segments.
  */
-class Redis extends Adapter
+class Redis extends Adapter implements
+    Feature\Relationships,
+    Feature\Upserts,
+    Feature\ConnectionId
 {
     public const string KEY_PREFIX = 'utopia';
 
     public const string SEP = ':';
 
-    /**
-     * Default SCAN MATCH batch size — also the variadic DEL chunk size
-     * used by collection purge. Aligned with the test harness teardown
-     * documented in Contract.md.
-     */
     private const int SCAN_BATCH_SIZE = 500;
 
-    /**
-     * Maximum depth for `json_decode` when reading document payloads and
-     * meta-hash fields. Matches the PHP default; hoisted so the value is
-     * named once instead of repeated 8+ times across the file.
-     */
     private const int JSON_DECODE_DEPTH = 512;
 
     private RedisClient $client;
@@ -85,2911 +68,2451 @@ class Redis extends Adapter
      */
     private array $journalStack = [];
 
+    private bool $supportForAttributes = true;
+
     public function __construct(RedisClient $client)
     {
         $this->client = $client;
     }
 
-    /**
-     * Join the supplied parts with `SEP`. Does NOT prepend `KEY_PREFIX` —
-     * call sites compose the prefix by passing `$this->ns()` (which is
-     * `'KEY_PREFIX:{namespace}:{database}'`) as the first argument.
-     */
-    private function key(string ...$parts): string
+    public function getDriver(): mixed
     {
-        return \implode(self::SEP, $parts);
+        return 'redis';
     }
 
     /**
-     * Build the `'KEY_PREFIX:{namespace}:{database}'` prefix shared by
-     * every adapter-produced key. All call sites that construct a Redis
-     * key MUST pass `$this->ns()` as the first argument to `key()` —
-     * passing the raw namespace/database produces unprefixed keys that
-     * collide across processes.
+     * @return array<Capability>
      */
-    private function ns(): string
-    {
-        return $this->nsFor($this->getNamespace(), $this->getDatabase());
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::Schemas,
+            Capability::Fulltext,
+            Capability::Casting,
+            Capability::QueryContains,
+            Capability::BatchOperations,
+            Capability::BatchCreateAttributes,
+            Capability::AttributeResizing,
+            Capability::Objects,
+            Capability::Operators,
+            Capability::OrderRandom,
+            Capability::DefinedAttributes,
+            Capability::NestedTransactions,
+            Capability::PCRE,
+            Capability::Regex,
+        ]);
     }
 
-    /**
-     * Variant of `ns()` that targets a specific database name within the
-     * current namespace. Used by `exists()` / `delete()` and similar
-     * cross-database operations where the Adapter's bound database is
-     * not the database under inspection.
-     */
-    private function nsFor(string $namespace, string $database): string
+    public function ping(): bool
     {
-        return self::KEY_PREFIX . self::SEP . $namespace . self::SEP . $database;
+        return (bool) $this->client->ping();
     }
 
-    /**
-     * Build the namespace-only prefix `'KEY_PREFIX:{namespace}'`.
-     * Used for keys that are shared across all databases in a namespace,
-     * such as the database-registry SET (`dbs`). Unlike `ns()` this does
-     * NOT include the currently bound database name, so `create()`,
-     * `exists()`, `list()`, and `delete()` all read/write the same key
-     * regardless of which database is currently selected.
-     */
-    private function nsBase(): string
+    public function reconnect(): void
     {
-        return self::KEY_PREFIX . self::SEP . $this->getNamespace();
     }
 
-    /**
-     * Build the document storage key. Lower-cases `$id` to match MariaDB's
-     * default case-insensitive UID semantics. Under shared tables every doc
-     * key is bucketed by tenant so two tenants can hold the same id without
-     * colliding — `null` tenants land under the `_` bucket alongside global
-     * METADATA rows.
-     */
-    private function docKey(string $collection, string $id, int|string|null $tenant = null): string
+    public function startTransaction(): bool
     {
-        $id = \strtolower($id);
-        if (! $this->getSharedTables()) {
-            return $this->key($this->ns(), 'doc', $collection, $id);
-        }
-
-        $bucket = $this->bucketFor($tenant);
+        $this->journalStack[] = [];
+        $this->inTransaction++;
 
-        return $this->key($this->ns(), 'doc', 't', $bucket, $collection, $id);
+        return true;
     }
 
-    /**
-     * Build the doc-id index SET key for a collection. Tenant-scoped under
-     * shared tables so per-tenant `find()` / `count()` see only their own
-     * ids and a recreated collection does not inherit foreign ids.
-     */
-    private function idxKey(string $collection, int|string|null $tenant = null): string
+    public function commitTransaction(): bool
     {
-        if (! $this->getSharedTables()) {
-            return $this->key($this->ns(), 'idx', $collection);
+        if ($this->inTransaction === 0) {
+            return false;
         }
 
-        return $this->key($this->ns(), 'idx', 't', $this->bucketFor($tenant), $collection);
-    }
-
-    /**
-     * Build the sequence counter key for a collection. Tenant-scoped under
-     * shared tables so each tenant gets an independent monotonic id space.
-     */
-    private function seqKey(string $collection, int|string|null $tenant = null): string
-    {
-        if (! $this->getSharedTables()) {
-            return $this->key($this->ns(), 'seq', $collection);
+        $frame = \array_pop($this->journalStack);
+        if ($frame !== null && $frame !== [] && $this->journalStack !== []) {
+            $outerIndex = \count($this->journalStack) - 1;
+            \array_push($this->journalStack[$outerIndex], ...$frame);
         }
+        $this->inTransaction--;
 
-        return $this->key($this->ns(), 'seq', 't', $this->bucketFor($tenant), $collection);
+        return true;
     }
 
-    /**
-     * Resolve the tenant-bucket segment for shared-tables doc/idx/seq keys,
-     * mapping `null` to the literal `'_'` so all shared-tables keys share a
-     * single bucket convention.
-     */
-    private function bucketFor(int|string|null $tenant): string
+    public function rollbackTransaction(): bool
     {
-        if ($tenant === null) {
-            $tenant = $this->getTenant();
+        if ($this->inTransaction === 0) {
+            return false;
         }
 
-        return $tenant === null ? '_' : (string) $tenant;
-    }
-
-    private function encode(Document $document): string
-    {
-        return \json_encode(
-            $document->getArrayCopy(),
-            JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION
-        );
-    }
-
-    private function decode(string $payload): Document
-    {
         try {
-            /** @var array<string, mixed> $data */
-            $data = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
-        } catch (\JsonException $e) {
-            throw new DatabaseException('Document decode failed: ' . $e->getMessage(), 0, $e);
+            $this->rollbackJournal();
+            $this->inTransaction--;
+        } catch (\Throwable $error) {
+            $this->inTransaction = 0;
+            $this->journalStack = [];
+
+            throw $error;
         }
 
-        return new Document($data);
+        return true;
     }
 
-    /**
-     * Single-shot wrapper for journal-tracked Redis operations. Does NOT
-     * retry — Redis transient errors propagate as `TransactionException`.
-     * Retrying here would replay journal side-effects (duplicate entries,
-     * non-idempotent commands like `INCR` on the sequence key advancing
-     * twice) so we leave retry policy to call sites that can prove
-     * idempotency. OCC support via WATCH/MULTI/EXEC is a follow-up
-     * (see Contract.md). `getSupportForTransactionRetries()` returns
-     * `false` so the shared trait suite skips OCC-retry assertions.
-     *
-     * @param callable(RedisClient): mixed $fn
-     */
-    protected function tx(callable $fn): mixed
+    public function create(string $name): bool
     {
-        try {
-            return $fn($this->client);
-        } catch (\RedisException $exception) {
-            throw new TransactionException('tx failed: ' . $exception->getMessage(), 0, $exception);
-        }
+        $name = $this->filter($name);
+        $dbsKey = $this->key($this->nsBase(), 'dbs');
+
+        $this->tx(fn (RedisClient $client) => $client->sAdd($dbsKey, $name));
+
+        return true;
     }
 
-    /**
-     * Persist a document's permissions into the inverted role/action sets and
-     * the per-document role->letters HASH. The same writes are journalled so
-     * T56 can revert them on rollback.
-     *
-     * NOTE: opens its own `multi(\Redis::PIPELINE)` block. MUST NOT be wrapped
-     * inside a MULTI/EXEC: phpredis does not support nested MULTI, and
-     * pipelining inside a transaction would queue commands incorrectly. If
-     * `tx()` ever gains real WATCH/MULTI/EXEC, this method must be refactored
-     * to either share the outer connection's mode, take an `inMulti` flag,
-     * or be split into a non-pipelined variant. Same constraint applies to
-     * `clearPermissions()` and `getSequences()`.
-     */
-    private function writePermissions(string $collection, string $id, Document $document): void
+    public function exists(string $database, ?string $collection = null): bool
     {
-        // Document keys (`doc:{col}:{id}`) and the index SET (`idx:{col}`) both
-        // use `\strtolower($id)`. The inverted permission SETs must follow the
-        // same convention so `applyPermissionFilter()` can intersect ids from
-        // the index SET with the perm SETs without case mismatch.
-        $id = \strtolower($id);
+        $database = $this->filter($database);
+        $dbsKey = $this->key($this->nsBase(), 'dbs');
 
-        $byRole = [];
-        foreach (Database::PERMISSIONS as $type) {
-            foreach ($document->getPermissionsByType($type) as $role) {
-                $byRole[$role][] = self::actionLetter($type);
-            }
+        if ((bool) $this->client->sIsMember($dbsKey, $database) === false) {
+            return false;
         }
 
-        if ($byRole === []) {
-            return;
+        if ($collection === null) {
+            return true;
         }
 
-        $hashKey = $this->permDocKey($collection, $id);
-        $hashFields = [];
-        $writes = [];
-        foreach ($byRole as $role => $letters) {
-            $unique = \array_values(\array_unique($letters));
-            \sort($unique);
-            $hashFields[$role] = \implode(',', $unique);
-            foreach ($unique as $letter) {
-                $writes[] = [$role, $letter];
-            }
-        }
+        $collection = $this->filter($collection);
+        $namespace = $this->getNamespace();
+        $colsKey = $this->key($this->nsFor($namespace, $database), 'cols');
 
-        // Pipeline the SADD writes so a doc with N (role,action) pairs hits
-        // Redis in a single round trip rather than N+1 sequential sends.
-        $this->client->multi(\Redis::PIPELINE);
-        try {
-            foreach ($writes as [$role, $letter]) {
-                $this->client->sAdd($this->permKey($collection, $letter, $role), $id);
-            }
-            $this->client->hMSet($hashKey, $hashFields);
-            $this->client->exec();
-        } catch (\Throwable $e) {
-            // PIPELINE-mode discard is version-dependent across phpredis
-            // (no-op in 5.x, raises in some 4.x). Swallow any failure here
-            // so we propagate the original cause, not a teardown error.
-            try {
-                $this->client->discard();
-            } catch (\Throwable) {
-                // ignore
-            }
-            throw $e;
+        return (bool) $this->client->sIsMember($colsKey, $collection);
+    }
+
+    public function list(): array
+    {
+        $dbsKey = $this->key($this->nsBase(), 'dbs');
+        /** @var array<int, string>|false $names */
+        $names = $this->client->sMembers($dbsKey);
+        if ($names === false) {
+            $names = [];
         }
 
-        // Journal one entry per (role, letter) pair so rollback dispatches
-        // through the existing 'createPerm' case without a bespoke handler.
-        foreach ($writes as [$role, $letter]) {
-            $this->journal('createPerm', [
-                'collection' => $collection,
-                'id' => $id,
-                'role' => $role,
-                'letter' => $letter,
-            ]);
+        $databases = [];
+        foreach ($names as $name) {
+            $databases[] = new Document(['name' => $name]);
         }
+
+        return $databases;
     }
 
-    /**
-     * Strip every permission entry for ($collection, $id) from the inverted
-     * sets and the per-doc HASH, recording the previous state in the journal
-     * so T56 can replay it on rollback.
-     *
-     * NOTE: same nested-pipeline constraint as `writePermissions()`. MUST NOT
-     * be wrapped inside a MULTI/EXEC. See `writePermissions()` docblock for
-     * the refactor checklist if `tx()` ever gains real transaction support.
-     */
-    private function clearPermissions(string $collection, string $id): void
+    public function delete(string $name): bool
     {
-        // Mirror writePermissions(): all perm-set operations key off the
-        // lowercased id so reads and writes stay symmetric.
-        $id = \strtolower($id);
-        $hashKey = $this->permDocKey($collection, $id);
-        /** @var array<string, string>|false $hash */
-        $hash = $this->client->hGetAll($hashKey);
-        if ($hash === false || $hash === []) {
-            return;
-        }
+        $name = $this->filter($name);
+        $namespace = $this->getNamespace();
+        $dbsKey = $this->key($this->nsBase(), 'dbs');
+        $colsKey = $this->key($this->nsFor($namespace, $name), 'cols');
 
-        $removals = [];
-        foreach ($hash as $role => $letterCsv) {
-            if ($letterCsv === '') {
-                continue;
-            }
-            foreach (\explode(',', $letterCsv) as $letter) {
-                $removals[] = [$role, $letter];
+        $this->tx(function (RedisClient $client) use ($name, $namespace, $dbsKey, $colsKey): void {
+            /** @var array<int, string>|false $collections */
+            $collections = $client->sMembers($colsKey);
+            if (\is_array($collections)) {
+                foreach ($collections as $collection) {
+                    $this->purgeCollectionKeys($client, $namespace, $name, $collection);
+                }
             }
-        }
 
-        // Pipeline the SREMs and HDEL together — one round trip per call site.
-        $this->client->multi(\Redis::PIPELINE);
-        try {
-            foreach ($removals as [$role, $letter]) {
-                $this->client->sRem($this->permKey($collection, $letter, $role), $id);
-            }
-            $this->client->del($hashKey);
-            $this->client->exec();
-        } catch (\Throwable $e) {
-            // PIPELINE-mode discard is version-dependent across phpredis;
-            // swallow the teardown error so we surface the original cause.
-            try {
-                $this->client->discard();
-            } catch (\Throwable) {
-                // ignore
-            }
-            throw $e;
-        }
+            $client->del($colsKey);
+            $client->sRem($dbsKey, $name);
+        });
 
-        // Emit one 'deletePerm' per pair so rollback can replay each SADD
-        // and rehydrate the per-doc HASH entry independently.
-        foreach ($removals as [$role, $letter]) {
-            $this->journal('deletePerm', [
-                'collection' => $collection,
-                'id' => $id,
-                'role' => $role,
-                'letter' => $letter,
-                'previous' => $hash[$role] ?? '',
-            ]);
-        }
+        return true;
     }
 
-    /**
-     * Restrict $ids to those visible to the current authorization context for
-     * the given $action. Returns $ids unchanged when authorization is off so
-     * privileged code paths bypass the filter.
-     *
-     * @param array<int, string> $ids
-     * @return array<int, string>
-     */
-    private function applyPermissionFilter(string $collection, array $ids, string $action): array
+    public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
     {
-        if ($ids === []) {
-            return $ids;
-        }
-        if ($this->authorization->getStatus() === false) {
-            return $ids;
+        $id = $this->filter($name);
+        $colsKey = $this->key($this->ns(), 'cols');
+        $metaKey = $this->key($this->ns(), 'meta', $id);
+        $idxKey = $this->idxKey($id);
+
+        if ((bool) $this->client->exists($metaKey)) {
+            throw new DuplicateException('Collection already exists');
         }
 
-        $roles = $this->authorization->getRoles();
-        if ($roles === []) {
-            return [];
+        $attributePayload = [];
+        foreach ($attributes as $attribute) {
+            $attributePayload[] = [
+                Document::ID => $attribute->key,
+                'key' => $attribute->key,
+                'type' => $attribute->type->value,
+                'size' => $attribute->size,
+                'signed' => $attribute->signed,
+                'array' => $attribute->array,
+                'required' => $attribute->required,
+            ];
         }
 
-        $letter = self::actionLetter($action);
-        $keys = [];
-        foreach ($roles as $role) {
-            $keys[] = $this->permKey($collection, $letter, $role);
+        $indexPayload = [];
+        foreach ($indexes as $index) {
+            $indexPayload[] = [
+                Document::ID => $index->key,
+                'key' => $index->key,
+                'type' => $index->type->value,
+                'attributes' => $index->attributes,
+                'lengths' => $index->lengths,
+                'orders' => $index->getAttribute('orders', []),
+            ];
         }
 
-        if (\count($keys) === 1) {
-            /** @var array<int, string>|false $allowed */
-            $allowed = $this->client->sMembers($keys[0]);
-        } else {
-            $first = \array_shift($keys);
-            /** @var array<int, string>|false $allowed */
-            $allowed = $this->client->sUnion($first, ...$keys);
-        }
-        if ($allowed === false || $allowed === []) {
-            return [];
-        }
+        $schema = new Document([
+            Document::ID => $id,
+            'name' => $name,
+            'attributes' => $attributePayload,
+            'indexes' => $indexPayload,
+        ]);
 
-        $allowedSet = \array_flip($allowed);
+        $this->tx(function (RedisClient $client) use ($id, $colsKey, $metaKey, $idxKey, $schema, $attributePayload, $indexPayload): void {
+            $client->hMSet($metaKey, [
+                'schema' => \json_encode($schema->getArrayCopy(), JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
+                'attrs' => \json_encode($attributePayload, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
+                'indexes' => \json_encode($indexPayload, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
+                'docCount' => '0',
+                'sizeBytes' => '0',
+            ]);
+            $client->del($idxKey);
+            $client->sAdd($colsKey, $id);
+        });
 
-        return \array_values(\array_filter($ids, static fn (string $id): bool => isset($allowedSet[$id])));
+        return true;
     }
 
-    /**
-     * Translate a `Database::PERMISSION_*` action string to the single-letter
-     * suffix used in `{ns}:{db}:perm:{col}:{letter}:{role}` set keys.
-     */
-    private static function actionLetter(string $action): string
+    public function deleteCollection(string $id): bool
     {
-        return match ($action) {
-            Database::PERMISSION_READ => 'r',
-            Database::PERMISSION_CREATE => 'c',
-            Database::PERMISSION_UPDATE => 'u',
-            Database::PERMISSION_DELETE => 'd',
-            Database::PERMISSION_WRITE => 'w',
-            default => throw new DatabaseException('Unknown permission action: ' . $action),
-        };
-    }
+        $id = $this->filter($id);
+        $namespace = $this->getNamespace();
+        $database = $this->getDatabase();
+        $colsKey = $this->key($this->ns(), 'cols');
 
-    /**
-     * Resolve the tenant-bucket segment for shared-tables perm keys, mapping
-     * a null tenant to the literal `'_'` so all shared-tables perm keys share
-     * a single inversion convention. Returns null when shared tables are off.
-     */
-    private function tenantBucket(): ?string
-    {
-        if (! $this->getSharedTables()) {
-            return null;
-        }
-        $tenant = $this->getTenant();
+        $this->tx(function (RedisClient $client) use ($id, $namespace, $database, $colsKey): void {
+            $this->purgeCollectionKeys($client, $namespace, $database, $id);
+            $client->sRem($colsKey, $id);
+        });
 
-        return $tenant === null ? '_' : (string) $tenant;
+        return true;
     }
 
-    /**
-     * Build the role/action set key, scoping by tenant under shared tables so
-     * cross-tenant role overlaps don't leak document ids.
-     */
-    private function permKey(string $collection, string $letter, string $role): string
+    public function analyzeCollection(string $collection): bool
     {
-        $bucket = $this->tenantBucket();
-        if ($bucket !== null) {
-            return $this->ns() . self::SEP . 'perm' . self::SEP . 't' . self::SEP . $bucket . self::SEP . $collection . self::SEP . $letter . self::SEP . $role;
-        }
-
-        return $this->ns() . self::SEP . 'perm' . self::SEP . $collection . self::SEP . $letter . self::SEP . $role;
+        return false;
     }
 
-    /**
-     * Build the per-document role->letters HASH key for ($collection, $id),
-     * applying the same tenant scoping as `permKey()` so reads/writes stay
-     * symmetric under shared tables.
-     */
-    private function permDocKey(string $collection, string $id): string
+    public function getSizeOfCollection(string $collection): int
     {
-        $bucket = $this->tenantBucket();
-        if ($bucket !== null) {
-            return $this->ns() . self::SEP . 'perm' . self::SEP . 't' . self::SEP . $bucket . self::SEP . 'doc' . self::SEP . $collection . self::SEP . $id;
-        }
+        return $this->computeCollectionSize($collection);
+    }
 
-        return $this->ns() . self::SEP . 'perm' . self::SEP . 'doc' . self::SEP . $collection . self::SEP . $id;
+    public function getSizeOfCollectionOnDisk(string $collection): int
+    {
+        return $this->computeCollectionSize($collection);
     }
 
-    /**
-     * Append a mutation entry to the topmost journal frame. Outside a
-     * transaction the entry is dropped — non-transactional writes pay
-     * zero overhead. The `op` discriminator drives `rollbackJournal()`'s
-     * dispatch to raw inverse helpers.
-     *
-     * @param array<string, mixed> $payload
-     */
-    protected function journal(string $op, array $payload): void
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        if ($this->inTransaction === 0) {
-            return;
+        $collection = $this->filter($collection);
+        $id = $this->filter($attribute->key);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
+
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
         }
-        $this->journalStack[\count($this->journalStack) - 1][] = [
-            'op' => $op,
-            'payload' => $payload,
+
+        $record = [
+            Document::ID => $id,
+            'key' => $id,
+            'type' => $attribute->type->value,
+            'size' => $attribute->size,
+            'signed' => $attribute->signed,
+            'array' => $attribute->array,
+            'required' => $attribute->required,
         ];
+
+        $this->tx(function (RedisClient $client) use ($metaKey, $record): void {
+            $attrs = $this->readAttributesField($client, $metaKey);
+            $attrs = $this->upsertAttributeRecord($attrs, $record);
+            $client->hSet($metaKey, 'attrs', \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
+
+        return true;
     }
 
-    /**
-     * Pop the topmost journal frame and replay its inverse operations in
-     * reverse order. Uses raw `\Redis` client commands only — calling a
-     * public adapter method would re-enter `journal()` and recurse
-     * infinitely. New `op` discriminators must be added to the dispatch
-     * switch below.
-     */
-    protected function rollbackJournal(): void
+    public function createAttributes(string $collection, array $attributes): bool
     {
-        $frame = \array_pop($this->journalStack);
-        if ($frame === null) {
-            return;
+        foreach ($attributes as $attribute) {
+            $this->createAttribute($collection, $attribute);
         }
 
-        for ($i = \count($frame) - 1; $i >= 0; $i--) {
-            $entry = $frame[$i];
-            $op = $entry['op'];
-            $payload = $entry['payload'];
+        return true;
+    }
 
-            switch ($op) {
-                case 'createDoc':
-                    /** @var string $collection */
-                    $collection = $payload['collection'];
-                    /** @var string $id */
-                    $id = $payload['id'];
-                    $this->rawDeleteDoc(
-                        $collection,
-                        $id,
-                        isset($payload['docKey']) ? (string) $payload['docKey'] : null,
-                        isset($payload['idxKey']) ? (string) $payload['idxKey'] : null,
-                        isset($payload['permDocKey']) ? (string) $payload['permDocKey'] : null,
-                    );
-                    break;
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
+    {
+        $collection = $this->filter($collection);
+        $id = $this->filter($attribute->key);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
-                case 'deleteDoc':
-                    /** @var string $collection */
-                    $collection = $payload['collection'];
-                    /** @var string $id */
-                    $id = $payload['id'];
-                    /** @var string $beforePayload */
-                    $beforePayload = $payload['payload'];
-                    $this->rawRestoreDoc(
-                        $collection,
-                        $id,
-                        $beforePayload,
-                        isset($payload['docKey']) ? (string) $payload['docKey'] : null,
-                        isset($payload['idxKey']) ? (string) $payload['idxKey'] : null,
-                    );
-                    break;
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
+        }
 
-                case 'updateDoc':
-                    /** @var string $collection */
-                    $collection = $payload['collection'];
-                    /** @var string $id */
-                    $id = $payload['id'];
-                    /** @var string $beforePayload */
-                    $beforePayload = $payload['payload'];
-                    $docKey = isset($payload['docKey']) ? (string) $payload['docKey'] : $this->docKey($collection, $id);
-                    $this->client->set($docKey, $beforePayload);
-                    // If the update changed the id, the new key must be removed
-                    // and the old id restored to the index set.
-                    if (isset($payload['newId']) && \is_string($payload['newId']) && $payload['newId'] !== $id) {
-                        $newId = $payload['newId'];
-                        $newDocKey = isset($payload['newDocKey']) ? (string) $payload['newDocKey'] : $this->docKey($collection, $newId);
-                        $this->client->del($newDocKey);
-                        $idxKey = isset($payload['idxKey']) ? (string) $payload['idxKey'] : $this->idxKey($collection);
-                        $this->client->sRem($idxKey, \strtolower($newId));
-                        $this->client->sAdd($idxKey, \strtolower($id));
-                    }
-                    break;
+        if (! empty($newKey) && $newKey !== $id) {
+            $this->renameAttribute($collection, $id, $newKey);
+            $id = $this->filter($newKey);
+        }
 
-                case 'createPerm':
-                    // Inverse of writePermissions: drop the (role, letter)
-                    // membership and the per-doc HASH entry for that role.
-                    /** @var string $collection */
-                    $collection = $payload['collection'];
-                    /** @var string $letter */
-                    $letter = $payload['letter'];
-                    /** @var string $role */
-                    $role = $payload['role'];
-                    /** @var string $id */
-                    $id = $payload['id'];
-                    $this->client->sRem($this->permKey($collection, $letter, $role), $id);
-                    $this->client->hDel($this->permDocKey($collection, $id), $role);
-                    break;
+        $record = [
+            Document::ID => $id,
+            'key' => $id,
+            'type' => $attribute->type->value,
+            'size' => $attribute->size,
+            'signed' => $attribute->signed,
+            'array' => $attribute->array,
+            'required' => $attribute->required,
+        ];
 
-                case 'deletePerm':
-                    // Inverse of clearPermissions: restore the (role, letter)
-                    // membership and rehydrate the per-doc HASH entry.
-                    /** @var string $collection */
-                    $collection = $payload['collection'];
-                    /** @var string $letter */
-                    $letter = $payload['letter'];
-                    /** @var string $role */
-                    $role = $payload['role'];
-                    /** @var string $id */
-                    $id = $payload['id'];
-                    $this->client->sAdd($this->permKey($collection, $letter, $role), $id);
-                    if (isset($payload['previous']) && \is_string($payload['previous']) && $payload['previous'] !== '') {
-                        $this->client->hSet($this->permDocKey($collection, $id), $role, $payload['previous']);
-                    }
-                    break;
+        $this->tx(function (RedisClient $client) use ($metaKey, $record): void {
+            $attrs = $this->readAttributesField($client, $metaKey);
+            $attrs = $this->upsertAttributeRecord($attrs, $record);
+            $client->hSet($metaKey, 'attrs', \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-                default:
-                    throw new TransactionException('Unknown journal op: ' . $op);
-            }
-        }
+        return true;
     }
 
-    /**
-     * Pop the topmost journal frame and, when nested, splice its entries
-     * onto the parent frame so an outer rollback still rewinds inner
-     * work. At the outermost level the frame is discarded — Wave-2
-     * writes go directly to Redis (no two-phase commit), so the journal
-     * exists purely for rollback compensation.
-     */
-    protected function commitJournal(): void
+    public function deleteAttribute(string $collection, string $id): bool
     {
-        $frame = \array_pop($this->journalStack);
-        if ($frame === null) {
-            return;
-        }
+        $collection = $this->filter($collection);
+        $id = $this->filter($id);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
-        if ($frame !== [] && $this->journalStack !== []) {
-            $outerIndex = \count($this->journalStack) - 1;
-            \array_push($this->journalStack[$outerIndex], ...$frame);
+        if ((bool) $this->client->exists($metaKey) === false) {
+            return true;
         }
-    }
 
-    private function rawDeleteDoc(string $collection, string $id, ?string $docKey = null, ?string $idxKey = null, ?string $permDocKey = null): void
-    {
-        // writePermissions/clearPermissions key the per-doc HASH off the
-        // lowercased id; lowercase here too so rollback of a mixed-case
-        // create id actually deletes the perm doc HASH that was written.
-        $lowerId = \strtolower($id);
-        $this->client->del($docKey ?? $this->docKey($collection, $lowerId));
-        $this->client->sRem($idxKey ?? $this->idxKey($collection), $lowerId);
-        $this->client->del($permDocKey ?? $this->permDocKey($collection, $lowerId));
-    }
+        $this->tx(function (RedisClient $client) use ($metaKey, $id): void {
+            $attrs = $this->readAttributesField($client, $metaKey);
+            $filtered = [];
+            foreach ($attrs as $attribute) {
+                $existingId = $this->recordIdentifier($attribute);
+                if ($this->filter($existingId) === $id) {
+                    continue;
+                }
+                $filtered[] = $attribute;
+            }
+            $client->hSet($metaKey, 'attrs', \json_encode($filtered, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-    private function rawRestoreDoc(string $collection, string $id, string $payload, ?string $docKey = null, ?string $idxKey = null): void
-    {
-        $lowerId = \strtolower($id);
-        $this->client->set($docKey ?? $this->docKey($collection, $lowerId), $payload);
-        $this->client->sAdd($idxKey ?? $this->idxKey($collection), $lowerId);
+        $this->dropDocumentField($collection, $id);
+
+        return true;
     }
 
-    /**
-     * @param array<int, Query> $queries
-     * @param array<int, string> $orderAttributes
-     * @param array<int, string> $orderTypes
-     * @param array<string, mixed> $cursor
-     * @return array<int, Document>
-     */
-    protected function evaluateQueries(string $collection, array $queries, ?int $limit, ?int $offset, array $orderAttributes, array $orderTypes, array $cursor, string $cursorDirection): array
+    public function renameAttribute(string $collection, string $old, string $new): bool
     {
-        $collectionId = $this->filter($collection);
-        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
+        $collection = $this->filter($collection);
+        $old = $this->filter($old);
+        $new = $this->filter($new);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
         if ((bool) $this->client->exists($metaKey) === false) {
             throw new NotFoundException('Collection not found');
         }
 
-        return $this->tx(function (RedisClient $client) use ($collectionId, $queries, $limit, $offset, $orderAttributes, $orderTypes, $cursor, $cursorDirection): array {
-            $documents = $this->loadCollectionDocuments($client, $collectionId, Database::PERMISSION_READ);
-            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
-            $documents = $this->orderDocuments($documents, $orderAttributes, $orderTypes, $cursorDirection);
-            $documents = $this->cursorDocuments($documents, $orderAttributes, $orderTypes, $cursor, $cursorDirection);
-
-            if (! \is_null($offset)) {
-                $documents = \array_slice($documents, $offset);
+        $this->tx(function (RedisClient $client) use ($metaKey, $old, $new): void {
+            $attrs = $this->readAttributesField($client, $metaKey);
+            $touched = false;
+            foreach ($attrs as $i => $attribute) {
+                $existingId = $this->recordIdentifier($attribute);
+                if ($this->filter($existingId) !== $old) {
+                    continue;
+                }
+                $attribute[Document::ID] = $new;
+                $attribute['key'] = $new;
+                $attrs[$i] = $attribute;
+                $touched = true;
             }
-            if (! \is_null($limit)) {
-                $documents = \array_slice($documents, 0, $limit);
+            if (! $touched) {
+                return;
             }
+            $client->hSet($metaKey, 'attrs', \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-            if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $documents = \array_reverse($documents);
-            }
+        $this->renameDocumentField($collection, $old, $new);
 
-            return $documents;
-        });
+        return true;
     }
 
-    public function getDriver(): mixed
+    #[\Override]
+    public function createRelationship(Relationship $relationship): bool
     {
-        return 'redis';
-    }
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $id = $relationship->key;
+        $twoWayKey = $relationship->twoWayKey;
+        $twoWay = $relationship->twoWay;
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
-    {
-    }
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                $this->registerRelationshipField($collection, $id);
+                if ($twoWay) {
+                    $this->registerRelationshipField($relatedCollection, $twoWayKey);
+                }
+                break;
+            case RelationType::OneToMany:
+                $this->registerRelationshipField($relatedCollection, $twoWayKey);
+                break;
+            case RelationType::ManyToOne:
+                $this->registerRelationshipField($collection, $id);
+                break;
+            case RelationType::ManyToMany:
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
 
-    public function ping(): bool
-    {
-        return (bool) $this->client->ping();
+        return true;
     }
 
-    public function reconnect(): void
+    #[\Override]
+    public function updateRelationship(Relationship $relationship, ?string $newKey = null, ?string $newTwoWayKey = null): bool
     {
-    }
-
-    protected function quote(string $string): string
-    {
-        return '"' . $string . '"';
-    }
-
-    public function getLimitForString(): int
-    {
-        return 4294967295;
-    }
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $newKey = $newKey !== null ? $this->filter($newKey) : null;
+        $newTwoWayKey = $newTwoWayKey !== null ? $this->filter($newTwoWayKey) : null;
+        $side = $relationship->side;
+        $twoWay = $relationship->twoWay;
 
-    public function getLimitForInt(): int
-    {
-        return 4294967295;
-    }
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($newKey !== null && $newKey !== $key) {
+                    $this->renameAttribute($collection, $key, $newKey);
+                }
+                if ($twoWay && $newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
+                    $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
+                        $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
+                    }
+                } else {
+                    if ($newKey !== null && $newKey !== $key) {
+                        $this->renameAttribute($collection, $key, $newKey);
+                    }
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
+                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
+                        $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
+                    }
+                } else {
+                    if ($newKey !== null && $newKey !== $key) {
+                        $this->renameAttribute($collection, $key, $newKey);
+                    }
+                }
+                break;
+            case RelationType::ManyToMany:
+                $junction = $this->resolveJunctionCollection($collection, $relatedCollection, $side);
+                if ($junction !== null) {
+                    if ($newKey !== null && $newKey !== $key) {
+                        $this->renameAttribute($junction, $key, $newKey);
+                    }
+                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
+                        $this->renameAttribute($junction, $twoWayKey, $newTwoWayKey);
+                    }
+                }
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
 
-    public function getLimitForAttributes(): int
-    {
-        return 1017;
+        return true;
     }
 
-    public function getLimitForIndexes(): int
+    #[\Override]
+    public function deleteRelationship(Relationship $relationship): bool
     {
-        return 64;
-    }
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
 
-    public function getMaxIndexLength(): int
-    {
-        return 1024;
-    }
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($side === RelationSide::Parent) {
+                    $this->deleteAttribute($collection, $key);
+                    if ($twoWay) {
+                        $this->deleteAttribute($relatedCollection, $twoWayKey);
+                    }
+                } else {
+                    $this->deleteAttribute($relatedCollection, $twoWayKey);
+                    if ($twoWay) {
+                        $this->deleteAttribute($collection, $key);
+                    }
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    $this->deleteAttribute($relatedCollection, $twoWayKey);
+                } else {
+                    $this->deleteAttribute($collection, $key);
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    $this->deleteAttribute($collection, $key);
+                } else {
+                    $this->deleteAttribute($relatedCollection, $twoWayKey);
+                }
+                break;
+            case RelationType::ManyToMany:
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
 
-    public function getMaxVarcharLength(): int
-    {
-        return 16381;
+        return true;
     }
 
-    public function getMaxUIDLength(): int
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
-        return 255;
-    }
+        $collection = $this->filter($collection);
+        $id = $this->filter($index->key);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
-    public function getMinDateTime(): \DateTime
-    {
-        return new \DateTime('0001-01-01 00:00:00');
-    }
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
+        }
 
-    public function getIdAttributeType(): string
-    {
-        // Sequence ids are sourced from `INCR`, which returns integers.
-        // The validator rejects string-valued sequences when this returns
-        // VAR_STRING, so mirror Memory's VAR_INTEGER stance.
-        return Database::VAR_INTEGER;
-    }
+        $type = $index->type->value;
+        $attributes = $index->attributes;
+        $lengths = $index->lengths;
+        $orders = $index->getAttribute('orders', []);
 
-    public function getSupportForSchemas(): bool
-    {
-        return true;
-    }
+        $this->tx(function (RedisClient $client) use ($metaKey, $collection, $id, $type, $attributes, $lengths, $orders): void {
+            $indexes = $this->readIndexesField($client, $metaKey);
 
-    public function getSupportForAttributes(): bool
-    {
-        return true;
-    }
+            foreach ($indexes as $existing) {
+                if (($existing[Document::ID] ?? $existing['key'] ?? null) === $id) {
+                    throw new DuplicateException('Index already exists');
+                }
+            }
 
-    public function setSupportForAttributes(bool $support): bool
-    {
-        return true;
-    }
+            if ($type === IndexType::Unique->value && ! empty($attributes)) {
+                $idxKey = $this->idxKey($collection);
+                /** @var array<int, string>|false $docIds */
+                $docIds = $client->sMembers($idxKey);
+                if (\is_array($docIds) && $docIds !== []) {
+                    $sharedTables = $this->getSharedTables();
+                    $currentTenant = $sharedTables ? $this->getTenant() : null;
+                    $docKeys = [];
+                    foreach ($docIds as $docId) {
+                        $docKeys[] = $this->docKey($collection, (string) $docId);
+                    }
+                    /** @var array<int, mixed> $payloads */
+                    $payloads = $client->mGet($docKeys);
+                    $seen = [];
+                    foreach ($payloads as $payload) {
+                        if (! \is_string($payload)) {
+                            continue;
+                        }
+                        $document = $this->decode($payload);
+                        if ($sharedTables) {
+                            $rowTenant = $document->getAttribute(Document::TENANT);
+                            if ($rowTenant !== $currentTenant) {
+                                continue;
+                            }
+                        }
+                        $signature = [];
+                        $hasNull = false;
+                        foreach ($attributes as $attribute) {
+                            $value = $this->resolveDocumentAttribute($document, (string) $attribute);
+                            if ($value === null) {
+                                $hasNull = true;
+                                break;
+                            }
+                            $signature[] = $this->normalizeIndexValue($value);
+                        }
+                        if ($hasNull) {
+                            continue;
+                        }
+                        if ($sharedTables) {
+                            \array_unshift($signature, $currentTenant);
+                        }
+                        $hash = \serialize($signature);
+                        if (isset($seen[$hash])) {
+                            throw new DuplicateException('Cannot create unique index: existing rows already contain duplicate values');
+                        }
+                        $seen[$hash] = true;
+                    }
+                }
+            }
 
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return false;
-    }
+            $indexes[] = [
+                Document::ID => $id,
+                'key' => $id,
+                'type' => $type,
+                'attributes' => \array_values($attributes),
+                'lengths' => \array_values($lengths),
+                'orders' => \array_values(\is_array($orders) ? $orders : []),
+            ];
 
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return false;
-    }
+            $client->hSet($metaKey, 'indexes', \json_encode($indexes, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-    public function getSupportForIndex(): bool
-    {
         return true;
     }
 
-    public function getSupportForIndexArray(): bool
+    public function deleteIndex(string $collection, string $id): bool
     {
-        return false;
-    }
+        $collection = $this->filter($collection);
+        $id = $this->filter($id);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
-    public function getSupportForCastIndexArray(): bool
-    {
-        return false;
-    }
+        if ((bool) $this->client->exists($metaKey) === false) {
+            return true;
+        }
 
-    public function getSupportForUniqueIndex(): bool
-    {
-        return true;
-    }
+        $this->tx(function (RedisClient $client) use ($metaKey, $id): void {
+            $indexes = $this->readIndexesField($client, $metaKey);
+            $filtered = [];
+            foreach ($indexes as $index) {
+                if (($index[Document::ID] ?? $index['key'] ?? null) === $id) {
+                    continue;
+                }
+                $filtered[] = $index;
+            }
+            $client->hSet($metaKey, 'indexes', \json_encode($filtered, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-    public function getSupportForFulltextIndex(): bool
-    {
         return true;
     }
 
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForCasting(): bool
+    public function renameIndex(string $collection, string $old, string $new): bool
     {
-        return true;
-    }
+        $collection = $this->filter($collection);
+        $old = $this->filter($old);
+        $new = $this->filter($new);
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
 
-    public function getSupportForQueryContains(): bool
-    {
-        return true;
-    }
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
+        }
 
-    public function getSupportForTimeouts(): bool
-    {
-        return false;
-    }
+        $this->tx(function (RedisClient $client) use ($metaKey, $old, $new): void {
+            $indexes = $this->readIndexesField($client, $metaKey);
+            $changed = false;
+            foreach ($indexes as $i => $index) {
+                if (($index[Document::ID] ?? $index['key'] ?? null) === $old) {
+                    $indexes[$i][Document::ID] = $new;
+                    $indexes[$i]['key'] = $new;
+                    $changed = true;
+                    break;
+                }
+            }
+            if (! $changed) {
+                return;
+            }
+            $client->hSet($metaKey, 'indexes', \json_encode(\array_values($indexes), JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
+        });
 
-    public function getSupportForRelationships(): bool
-    {
         return true;
     }
 
-    public function getSupportForUpdateLock(): bool
+    public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
     {
-        return false;
-    }
+        $col = $this->filter($collection->getId());
+        $payload = $this->client->get($this->docKey($col, $id));
 
-    public function getSupportForBatchOperations(): bool
-    {
-        return true;
-    }
+        if ((! \is_string($payload) || $payload === '') && $this->getSharedTables() && $col === Database::METADATA) {
+            $payload = $this->client->get($this->docKey($col, $id, '_'));
+        }
 
-    public function getSupportForAttributeResizing(): bool
-    {
-        return true;
-    }
+        if (! \is_string($payload) || $payload === '') {
+            return new Document([]);
+        }
 
-    public function getSupportForGetConnectionId(): bool
-    {
-        return false;
-    }
+        $document = $this->decode($payload);
 
-    public function getSupportForUpserts(): bool
-    {
-        return false;
-    }
+        if ($this->getSharedTables()) {
+            $rowTenant = $document->getAttribute(Document::TENANT);
+            $tenant = $this->getTenant();
+            $allowNullTenant = $col === Database::METADATA && $rowTenant === null;
+            if (! $allowNullTenant && $rowTenant !== $tenant) {
+                return new Document([]);
+            }
+        }
 
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return false;
-    }
+        if ($col !== Database::METADATA) {
+            $document = $this->surfaceRelationshipAttributes($col, $document);
+        }
 
-    public function getSupportForVectors(): bool
-    {
-        return false;
-    }
+        $selections = $this->extractSelections($queries);
+        if (! empty($selections) && ! \in_array('*', $selections, true)) {
+            $document = $this->projectDocument($document, $selections);
+        }
 
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return false;
+        return $document;
     }
 
-    public function getSupportForCaching(): bool
+    public function createDocument(Document $collection, Document $document): Document
     {
-        // The Redis adapter is itself the store; reads hit Redis directly and
-        // it runs with a no-op cache, so the Database cache layer is bypassed.
-        return false;
-    }
+        $col = $this->filter($collection->getId());
+        $id = $document->getId();
+        if ($id === '') {
+            $id = ID::unique();
+            $document->setAttribute(Document::ID, $id);
+        }
+        $tenant = $document->getTenant();
+        $docKey = $this->docKey($col, $id, $tenant);
+        $idxKey = $this->idxKey($col, $tenant);
+        $seqKey = $this->seqKey($col, $tenant);
+        $permDocKey = $this->permDocKey($col, $id);
 
-    public function getSupportForReconnection(): bool
-    {
-        return false;
-    }
+        return $this->tx(function (RedisClient $redis) use ($col, $id, $document, $docKey, $idxKey, $seqKey, $permDocKey): Document {
+            if ((bool) $redis->exists($docKey)) {
+                if ($this->skipDuplicates) {
+                    $existingPayload = $redis->get($docKey);
+                    if (\is_string($existingPayload) && $existingPayload !== '') {
+                        $existing = $this->decode($existingPayload);
+                        $document->setAttribute(Document::SEQUENCE, $existing->getSequence() ?? '');
+                    }
 
-    public function getSupportForHostname(): bool
-    {
-        return false;
-    }
+                    return $document;
+                }
+                throw new DuplicateException('Document already exists');
+            }
 
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
+            try {
+                $this->enforceUniqueIndexes($redis, $col, $document);
+            } catch (DuplicateException $e) {
+                if ($this->skipDuplicates) {
+                    return $document;
+                }
+                throw $e;
+            }
 
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return false;
-    }
+            $sequence = $document->getSequence();
+            if (empty($sequence)) {
+                $next = $redis->incr($seqKey);
+                $sequence = (string) $next;
+            } else {
+                $sequence = (string) $sequence;
+                $current = $redis->get($seqKey);
+                if (! \is_string($current) || (int) $sequence > (int) $current) {
+                    $redis->set($seqKey, $sequence);
+                }
+            }
+            $document->setAttribute(Document::SEQUENCE, $sequence);
 
-    public function getSupportForObject(): bool
-    {
-        return true;
-    }
+            $redis->set($docKey, $this->encode($document));
+            $redis->sAdd($idxKey, \strtolower($id));
 
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
-    }
+            $this->writePermissions($col, $id, $document);
+            $this->journal('createDoc', [
+                'collection' => $col,
+                'id' => $id,
+                'docKey' => $docKey,
+                'idxKey' => $idxKey,
+                'permDocKey' => $permDocKey,
+            ]);
 
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return false;
+            return $document;
+        });
     }
 
-    public function getSupportForOperators(): bool
+    public function createDocuments(Document $collection, array $documents): array
     {
-        return true;
-    }
+        $created = [];
+        foreach ($documents as $document) {
+            $created[] = $this->createDocument($collection, $document);
+        }
 
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
+        return $created;
     }
 
-    public function getSupportForSpatialIndexOrder(): bool
+    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        return false;
-    }
+        $col = $this->filter($collection->getId());
+        $oldKey = $this->docKey($col, $id);
+        $idxKey = $this->idxKey($col);
 
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+        $useNullTenant = false;
+        if ($col === Database::METADATA && $this->getSharedTables() && $this->getTenant() !== null) {
+            if ((bool) $this->client->exists($oldKey) === false) {
+                $oldKey = $this->docKey($col, $id, '_');
+                $useNullTenant = true;
+            }
+        }
 
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return false;
-    }
+        return $this->tx(function (RedisClient $redis) use ($col, $id, $document, $skipPermissions, $oldKey, $idxKey, $useNullTenant): Document {
+            $existingPayload = $redis->get($oldKey);
+            if (! \is_string($existingPayload) || $existingPayload === '') {
+                throw new NotFoundException('Document not found');
+            }
 
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
-    {
-        return false;
-    }
+            $existing = $this->decode($existingPayload);
+            if ($col !== Database::METADATA) {
+                $existing = $this->surfaceRelationshipAttributes($col, $existing);
+            }
+            $newId = $document->getId() !== '' ? $document->getId() : $id;
+            $newKey = $useNullTenant ? $this->docKey($col, $newId, '_') : $this->docKey($col, $newId);
+            $effectiveIdxKey = $useNullTenant ? $this->idxKey($col, '_') : $idxKey;
 
-    public function getSupportForMultipleFulltextIndexes(): bool
-    {
-        return false;
-    }
+            if ($newId !== $id && (bool) $redis->exists($newKey)) {
+                throw new DuplicateException('Document already exists');
+            }
 
-    public function getSupportForIdenticalIndexes(): bool
-    {
-        return false;
-    }
+            $resolved = $this->applyOperators($document->getArrayCopy(), $existing->getArrayCopy());
+            $merged = \array_merge($existing->getArrayCopy(), $resolved);
+            $merged[Document::ID] = $newId;
+            $mergedDocument = new Document($merged);
 
-    public function getSupportForOrderRandom(): bool
-    {
-        return true;
-    }
+            $this->enforceUniqueIndexes($redis, $col, $mergedDocument, $id);
 
-    /**
-     * Get max BIGINT limit
-     *
-     * @return int
-     */
-    public function getLimitForBigInt(): int
-    {
-        return Database::MAX_BIG_INT;
-    }
+            $payload = $this->encode($mergedDocument);
 
-    public function getSupportForInternalCasting(): bool
-    {
-        return false;
-    }
+            if ($newId !== $id) {
+                $redis->del($oldKey);
+                $redis->sRem($effectiveIdxKey, \strtolower($id));
+            }
+            $redis->set($newKey, $payload);
+            $redis->sAdd($effectiveIdxKey, \strtolower($newId));
 
-    public function getSupportForUTCCasting(): bool
-    {
-        return false;
-    }
+            $this->journal('updateDoc', [
+                'collection' => $col,
+                'id' => $id,
+                'newId' => $newId,
+                'payload' => $existingPayload,
+                'docKey' => $oldKey,
+                'newDocKey' => $newKey,
+                'idxKey' => $effectiveIdxKey,
+            ]);
 
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return false;
-    }
+            if (! $skipPermissions) {
+                $this->clearPermissions($col, $id);
+                if ($newId !== $id) {
+                    $this->clearPermissions($col, $newId);
+                }
+                $this->writePermissions($col, $newId, $mergedDocument);
+            }
 
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
+            return $mergedDocument;
+        });
     }
 
-    public function getSupportNonUtfCharacters(): bool
+    public function updateDocuments(Document $collection, Document $updates, array $documents): int
     {
-        return false;
-    }
+        if (empty($documents)) {
+            return 0;
+        }
 
-    public function getSupportForTrigramIndex(): bool
-    {
-        return false;
-    }
+        $attrs = $updates->getAttributes();
+        $hasCreatedAt = ! empty($updates->getCreatedAt());
+        $hasUpdatedAt = ! empty($updates->getUpdatedAt());
+        $hasPermissions = $updates->offsetExists(Document::PERMISSIONS);
+        if (empty($attrs) && ! $hasCreatedAt && ! $hasUpdatedAt && ! $hasPermissions) {
+            return 0;
+        }
 
-    public function getSupportForPCRERegex(): bool
-    {
-        return true;
-    }
+        $col = $this->filter($collection->getId());
+        $documents = \array_values($documents);
 
-    public function getSupportForPOSIXRegex(): bool
-    {
-        return false;
-    }
+        return $this->tx(function (RedisClient $redis) use ($col, $documents, $updates, $attrs, $hasCreatedAt, $hasUpdatedAt, $hasPermissions): int {
+            $docKeys = [];
+            foreach ($documents as $doc) {
+                $docKeys[] = $this->docKey($col, $doc->getId());
+            }
 
-    public function getSupportForTransactionRetries(): bool
-    {
-        // The current `tx()` body is a network-error retry loop, not a
-        // WATCH/MULTI/EXEC OCC implementation. Reporting `false` keeps the
-        // shared trait's OCC-retry tests from running against semantics this
-        // adapter doesn't yet provide. Mirror Memory's stance until a real
-        // optimistic concurrency layer lands.
-        return false;
-    }
+            $redis->multi(\Redis::PIPELINE);
+            foreach ($docKeys as $docKey) {
+                $redis->get($docKey);
+            }
+            $existingPayloads = $redis->exec();
+            if (! \is_array($existingPayloads)) {
+                $existingPayloads = [];
+            }
 
-    public function getSupportForNestedTransactions(): bool
-    {
-        return true;
-    }
+            $relationshipKeys = [];
+            if ($col !== Database::METADATA) {
+                $metaKey = $this->key($this->ns(), 'meta', $col);
+                $attributes = $this->readAttributesField($redis, $metaKey);
+                $relationshipKeys = $this->extractRelationshipKeys($attributes);
+            }
 
-    public function getCountOfDefaultAttributes(): int
-    {
-        return \count(Database::INTERNAL_ATTRIBUTES);
-    }
+            $count = 0;
+            foreach ($documents as $i => $doc) {
+                $uid = $doc->getId();
+                $docKey = $docKeys[$i];
+                $existingPayload = $existingPayloads[$i] ?? false;
+                if (! \is_string($existingPayload) || $existingPayload === '') {
+                    continue;
+                }
 
-    public function getCountOfDefaultIndexes(): int
-    {
-        return \count(Database::INTERNAL_INDEXES);
-    }
+                $existing = $this->decode($existingPayload);
+                if (! empty($relationshipKeys)) {
+                    $existing = $this->surfaceRelationshipAttributesUsing($relationshipKeys, $existing);
+                }
+                $merged = $existing->getArrayCopy();
+                $resolved = $this->applyOperators($attrs, $merged);
+                foreach ($resolved as $attribute => $value) {
+                    $merged[$attribute] = $value;
+                }
+                if ($hasCreatedAt) {
+                    $merged[Document::CREATED_AT] = $updates->getCreatedAt();
+                }
+                if ($hasUpdatedAt) {
+                    $merged[Document::UPDATED_AT] = $updates->getUpdatedAt();
+                }
+                if ($hasPermissions) {
+                    $merged[Document::PERMISSIONS] = $updates->getPermissions();
+                }
 
-    public function getDocumentSizeLimit(): int
-    {
-        return 0;
-    }
+                $mergedDocument = new Document($merged);
+                $redis->set($docKey, $this->encode($mergedDocument));
 
-    public function getAttributeWidth(Document $collection): int
-    {
-        return 0;
-    }
+                $this->journal('updateDoc', [
+                    'collection' => $col,
+                    'id' => $uid,
+                    'newId' => $uid,
+                    'payload' => $existingPayload,
+                    'docKey' => $docKey,
+                ]);
 
-    public function getKeywords(): array
-    {
-        return [];
-    }
+                if ($hasPermissions) {
+                    $this->clearPermissions($col, $uid);
+                    $this->writePermissions($col, $uid, $mergedDocument);
+                }
 
-    /**
-     * @param array<int, string> $selections
-     */
-    protected function getAttributeProjection(array $selections, string $prefix): mixed
-    {
-        return $selections;
-    }
+                $count++;
+            }
 
-    public function getConnectionId(): string
-    {
-        return '0';
+            return $count;
+        });
     }
 
-    public function getInternalIndexesKeys(): array
+    #[\Override]
+    public function upsertDocuments(Document $collection, string $attribute, array $changes): array
     {
-        return [];
-    }
+        if (empty($changes)) {
+            return $changes;
+        }
 
-    public function getTenantQuery(string $collection, string $alias = ''): string
-    {
-        return '';
-    }
+        $col = $this->filter($collection->getId());
 
-    protected function execute(mixed $stmt): bool
-    {
-        return true;
-    }
+        return $this->tx(function (RedisClient $redis) use ($col, $attribute, $changes): array {
+            $results = [];
 
-    public function decodePoint(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Redis adapter');
-    }
+            $redis->multi(\Redis::PIPELINE);
+            foreach ($changes as $change) {
+                $document = $change->getNew();
+                $redis->get($this->docKey($col, $document->getId(), $document->getTenant()));
+            }
+            $existingPayloads = $redis->exec();
+            if (! \is_array($existingPayloads)) {
+                $existingPayloads = [];
+            }
 
-    public function decodeLinestring(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Redis adapter');
-    }
+            $relationshipKeys = [];
+            if ($col !== Database::METADATA) {
+                $metaKey = $this->key($this->ns(), 'meta', $col);
+                $attributes = $this->readAttributesField($redis, $metaKey);
+                $relationshipKeys = $this->extractRelationshipKeys($attributes);
+            }
 
-    public function decodePolygon(string $wkb): array
-    {
-        throw new DatabaseException('Spatial types are not implemented in the Redis adapter');
-    }
+            foreach ($changes as $i => $change) {
+                $document = $change->getNew();
+                $id = $document->getId();
+                $tenant = $document->getTenant();
+                $docKey = $this->docKey($col, $id, $tenant);
+                $idxKey = $this->idxKey($col, $tenant);
+                $seqKey = $this->seqKey($col, $tenant);
+                $existingPayload = $existingPayloads[$i] ?? false;
 
-    public function castingBefore(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
+                if (\is_string($existingPayload) && $existingPayload !== '') {
+                    $existing = $this->decode($existingPayload);
+                    if (! empty($relationshipKeys)) {
+                        $existing = $this->surfaceRelationshipAttributesUsing($relationshipKeys, $existing);
+                    }
+                    $existingArray = $existing->getArrayCopy();
+                    $resolved = $this->applyOperators($document->getArrayCopy(), $existingArray);
+                    $merged = \array_merge($existingArray, $resolved);
+                    $merged[Document::ID] = $id;
 
-    public function castingAfter(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
+                    if ($attribute !== '') {
+                        $previous = $existing->getAttribute($attribute);
+                        $delta = $document->getAttribute($attribute);
+                        $previousNumeric = \is_numeric($previous) ? $previous + 0 : 0;
+                        $deltaNumeric = \is_numeric($delta) ? $delta + 0 : 0;
+                        $merged[$attribute] = $previousNumeric + $deltaNumeric;
+                    }
 
-    public function setUTCDatetime(string $value): mixed
-    {
-        return $value;
-    }
+                    $mergedDocument = new Document($merged);
+                    $redis->set($docKey, $this->encode($mergedDocument));
 
-    /**
-     * Surface relationship attributes registered on the collection's meta.attrs
-     * as null when the document does not carry them — mirrors MariaDB selecting
-     * a `DEFAULT NULL` column even when no row has set it (and Memory's
-     * `documentToRow` null-surface pass).
-     *
-     * METADATA is exempt: relationship attributes for user collections are
-     * nested inside the metadata row's `attributes` payload, not stored as
-     * top-level keys. Surfacing nulls there would clobber that nested array.
-     */
-    private function surfaceRelationshipAttributes(string $collection, Document $document): Document
-    {
-        if ($collection === Database::METADATA) {
-            return $document;
-        }
+                    $this->journal('updateDoc', [
+                        'collection' => $col,
+                        'id' => $id,
+                        'newId' => $id,
+                        'payload' => $existingPayload,
+                        'docKey' => $docKey,
+                    ]);
 
-        $metaKey = $this->key($this->ns(), 'meta', $this->filter($collection));
-        $attributes = $this->readAttributesField($this->client, $metaKey);
-        $relationshipKeys = $this->extractRelationshipKeys($attributes);
-        if ($relationshipKeys === []) {
-            return $document;
-        }
+                    $this->clearPermissions($col, $id);
+                    $this->writePermissions($col, $id, $mergedDocument);
 
-        return $this->surfaceRelationshipAttributesUsing($relationshipKeys, $document);
-    }
+                    $results[] = $mergedDocument;
+                } else {
+                    $this->enforceUniqueIndexes($redis, $col, $document);
 
-    /**
-     * Loop-friendly companion to `surfaceRelationshipAttributes`. Callers that
-     * iterate large result sets (e.g. `find()` / `loadCollectionDocuments`)
-     * read meta.attrs once, derive the relationship key list via
-     * `extractRelationshipKeys`, and pass it here per document — avoiding N
-     * round trips to Redis for the same meta hash.
-     *
-     * @param array<int, string> $relationshipKeys
-     */
-    private function surfaceRelationshipAttributesUsing(array $relationshipKeys, Document $document): Document
-    {
-        if ($relationshipKeys === []) {
-            return $document;
-        }
+                    $sequence = $document->getSequence();
+                    if (empty($sequence)) {
+                        $next = $redis->incr($seqKey);
+                        $sequence = (string) $next;
+                    } else {
+                        $sequence = (string) $sequence;
+                        $current = $redis->get($seqKey);
+                        if (! \is_string($current) || (int) $sequence > (int) $current) {
+                            $redis->set($seqKey, $sequence);
+                        }
+                    }
+                    $document->setAttribute(Document::SEQUENCE, $sequence);
 
-        $payload = $document->getArrayCopy();
-        foreach ($relationshipKeys as $key) {
-            if (! \array_key_exists($key, $payload)) {
-                $document->setAttribute($key, null);
-            }
-        }
+                    $resolved = $this->applyOperators($document->getArrayCopy(), []);
+                    foreach ($resolved as $attr => $value) {
+                        $document->setAttribute($attr, $value);
+                    }
 
-        return $document;
-    }
+                    $redis->set($docKey, $this->encode($document));
+                    $redis->sAdd($idxKey, \strtolower($id));
 
-    /**
-     * Extract the list of relationship attribute keys from a decoded
-     * meta.attrs records array. Returned as a positional list so callers can
-     * iterate without extra `array_keys` calls.
-     *
-     * @param array<int, array<string, mixed>> $attributes
-     * @return array<int, string>
-     */
-    private function extractRelationshipKeys(array $attributes): array
-    {
-        $keys = [];
-        foreach ($attributes as $attribute) {
-            if (($attribute['type'] ?? null) !== Database::VAR_RELATIONSHIP) {
-                continue;
-            }
-            $key = (string) ($attribute['$id'] ?? $attribute['key'] ?? '');
-            if ($key === '') {
-                continue;
+                    $this->writePermissions($col, $id, $document);
+                    $this->journal('createDoc', [
+                        'collection' => $col,
+                        'id' => $id,
+                        'docKey' => $docKey,
+                        'idxKey' => $idxKey,
+                        'permDocKey' => $this->permDocKey($col, $id),
+                    ]);
+
+                    $results[] = $document;
+                }
             }
-            $keys[] = $key;
-        }
 
-        return $keys;
+            return $results;
+        });
     }
 
-    /**
-     * Rename a top-level field across every document in a collection. Mirrors
-     * Memory's `renameDocumentField`. Used by `updateRelationship` to migrate
-     * stored payloads when a relationship key is renamed.
-     *
-     * Schema-level (non-journalled): same convention as `createAttribute` /
-     * `renameAttribute` — schema mutations are not transactional and therefore
-     * do not register inverse entries with `journal()`. The transaction
-     * wrapper is used solely to surface `\RedisException` as
-     * `TransactionException`.
-     */
-    private function renameDocumentField(string $collection, string $oldKey, string $newKey): void
+    public function getSequences(string $collection, array $documents): array
     {
-        $collection = $this->filter($collection);
-        $oldKey = $this->filter($oldKey);
-        $newKey = $this->filter($newKey);
-
-        if ($oldKey === $newKey) {
-            return;
+        if (empty($documents)) {
+            return $documents;
         }
 
-        $idxKey = $this->idxKey($collection);
+        $col = $this->filter($collection);
 
-        $this->tx(function (RedisClient $client) use ($collection, $oldKey, $newKey, $idxKey): void {
-            /** @var array<int, string>|false $docIds */
-            $docIds = $client->sMembers($idxKey);
-            if (! \is_array($docIds) || $docIds === []) {
-                return;
+        $this->client->multi(\Redis::PIPELINE);
+        try {
+            $indexes = [];
+            foreach ($documents as $index => $doc) {
+                if (! empty($doc->getSequence())) {
+                    continue;
+                }
+                $this->client->get($this->docKey($col, $doc->getId(), $doc->getTenant()));
+                $indexes[] = $index;
             }
-
-            foreach ($docIds as $docId) {
-                $docKey = $this->docKey($collection, $docId);
-                $payload = $client->get($docKey);
-                if (! \is_string($payload) || $payload === '') {
-                    continue;
-                }
-
-                /** @var array<string, mixed> $decoded */
-                $decoded = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
-                if (! \array_key_exists($oldKey, $decoded)) {
-                    continue;
+            if ($indexes === []) {
+                try {
+                    $this->client->discard();
+                } catch (\Throwable) {
+                    // PIPELINE-mode discard is version-dependent across phpredis.
                 }
 
-                $decoded[$newKey] = $decoded[$oldKey];
-                unset($decoded[$oldKey]);
+                return $documents;
+            }
+            $payloads = $this->client->exec();
+        } catch (\Throwable $e) {
+            try {
+                $this->client->discard();
+            } catch (\Throwable) {
+                // PIPELINE-mode discard is version-dependent across phpredis.
+            }
+            throw new TransactionException('Failed to load sequences: '.$e->getMessage(), 0, $e);
+        }
+        if (! \is_array($payloads)) {
+            return $documents;
+        }
 
-                $client->set(
-                    $docKey,
-                    \json_encode($decoded, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION),
-                );
+        foreach ($indexes as $position => $index) {
+            $payload = $payloads[$position] ?? false;
+            if (! \is_string($payload) || $payload === '') {
+                continue;
             }
-        });
+            $existing = $this->decode($payload);
+            $sequence = $existing->getSequence();
+            if (! empty($sequence)) {
+                $documents[$index]->setAttribute(Document::SEQUENCE, (string) $sequence);
+            }
+        }
+
+        return $documents;
     }
 
-    /**
-     * Remove a top-level field from every document in a collection. Mirrors
-     * Memory's `dropDocumentField`. Used by `deleteRelationship` to scrub
-     * stored payloads when a relationship column is dropped.
-     *
-     * Same non-journalled schema-op contract as `renameDocumentField`.
-     */
-    private function dropDocumentField(string $collection, string $field): void
+    public function deleteDocument(string $collection, string $id): bool
     {
         $collection = $this->filter($collection);
-        $field = $this->filter($field);
+        $docKey = $this->docKey($collection, $id);
         $idxKey = $this->idxKey($collection);
 
-        $this->tx(function (RedisClient $client) use ($collection, $field, $idxKey): void {
-            /** @var array<int, string>|false $docIds */
-            $docIds = $client->sMembers($idxKey);
-            if (! \is_array($docIds) || $docIds === []) {
-                return;
+        return $this->tx(function (RedisClient $redis) use ($collection, $id, $docKey, $idxKey): bool {
+            $payload = $redis->get($docKey);
+            if (! \is_string($payload) || $payload === '') {
+                return false;
             }
 
-            foreach ($docIds as $docId) {
-                $docKey = $this->docKey($collection, $docId);
-                $payload = $client->get($docKey);
-                if (! \is_string($payload) || $payload === '') {
-                    continue;
-                }
-
-                /** @var array<string, mixed> $decoded */
-                $decoded = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
-                if (! \array_key_exists($field, $decoded)) {
-                    continue;
-                }
+            $this->journal('deleteDoc', [
+                'collection' => $collection,
+                'id' => $id,
+                'payload' => $payload,
+                'docKey' => $docKey,
+                'idxKey' => $idxKey,
+            ]);
 
-                unset($decoded[$field]);
+            $this->clearPermissions($collection, $id);
+            $redis->del($docKey);
+            $redis->sRem($idxKey, \strtolower($id));
 
-                $client->set(
-                    $docKey,
-                    \json_encode($decoded, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION),
-                );
-            }
+            return true;
         });
     }
 
-    /**
-     * Resolve the junction collection name for an M2M relationship. Mirrors
-     * `Database::getJunctionCollection` — the junction is named after the
-     * parent/child sequence pair (`_{parent}_{child}` for the parent side,
-     * reversed for the child side).
-     *
-     * Reads the METADATA collection's docs for both sides and extracts each
-     * `$sequence`. Returns null when either METADATA row is missing or has
-     * no sequence — callers treat that as a no-op (skip the rename).
-     */
-    private function resolveJunctionCollection(string $collection, string $relatedCollection, string $side): ?string
+    public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
     {
-        $collectionDoc = $this->loadMetadataDocument($collection);
-        $relatedDoc = $this->loadMetadataDocument($relatedCollection);
-        if ($collectionDoc === null || $relatedDoc === null) {
-            return null;
+        if (empty($sequences) && empty($permissionIds)) {
+            return 0;
         }
 
-        $collectionSequence = $collectionDoc->getSequence();
-        $relatedSequence = $relatedDoc->getSequence();
-        if ($collectionSequence === null || $relatedSequence === null || $collectionSequence === '' || $relatedSequence === '') {
-            return null;
-        }
+        $collection = $this->filter($collection);
+        $idxKey = $this->idxKey($collection);
 
-        return $side === Database::RELATION_SIDE_PARENT
-            ? '_' . $collectionSequence . '_' . $relatedSequence
-            : '_' . $relatedSequence . '_' . $collectionSequence;
-    }
+        return $this->tx(function (RedisClient $redis) use ($collection, $sequences, $permissionIds, $idxKey): int {
+            $sequenceSet = [];
+            foreach ($sequences as $sequence) {
+                $sequenceSet[(string) $sequence] = true;
+            }
 
-    /**
-     * Read a single METADATA document directly from the doc key, bypassing
-     * the public `getDocument` path so this helper can be called from inside
-     * schema operations (which build a Document collection lazily).
-     */
-    private function loadMetadataDocument(string $collection): ?Document
-    {
-        $id = $this->filter($collection);
-        $payload = $this->client->get($this->docKey(Database::METADATA, $id));
-        // Fall back to the null-tenant METADATA row under shared tables —
-        // bootstrap writes the global metadata schema with $tenant=null.
-        if ((! \is_string($payload) || $payload === '') && $this->getSharedTables()) {
-            $payload = $this->client->get($this->docKey(Database::METADATA, $id, '_'));
-        }
-        if (! \is_string($payload) || $payload === '') {
-            return null;
-        }
+            $allIds = $redis->sMembers($idxKey);
+            if (! \is_array($allIds)) {
+                $allIds = [];
+            }
 
-        return $this->decode($payload);
-    }
+            $docKeys = [];
+            $redis->multi(\Redis::PIPELINE);
+            foreach ($allIds as $id) {
+                $docKey = $this->docKey($collection, (string) $id);
+                $docKeys[(string) $id] = $docKey;
+                $redis->get($docKey);
+            }
+            $payloads = $redis->exec();
+            if (! \is_array($payloads)) {
+                $payloads = [];
+            }
 
-    // === @architect:T20 owns: schema + collection + attribute ops ===
+            $deleted = [];
+            foreach ($allIds as $position => $id) {
+                $payload = $payloads[$position] ?? false;
+                if (! \is_string($payload) || $payload === '') {
+                    continue;
+                }
+                $document = $this->decode($payload);
+                $matchesSequence = isset($sequenceSet[(string) $document->getSequence()]);
+                if ($matchesSequence) {
+                    $deleted[$document->getId()] = ['payload' => $payload, 'docKey' => $docKeys[(string) $id]];
+                }
+            }
 
-    public function create(string $name): bool
-    {
-        $name = $this->filter($name);
-        $dbsKey = $this->key($this->nsBase(), 'dbs');
+            foreach ($deleted as $documentId => $deleteEntry) {
+                $deletedDocKey = $deleteEntry['docKey'];
+                $this->journal('deleteDoc', [
+                    'collection' => $collection,
+                    'id' => (string) $documentId,
+                    'payload' => $deleteEntry['payload'],
+                    'docKey' => $deletedDocKey,
+                    'idxKey' => $idxKey,
+                ]);
+                $this->clearPermissions($collection, (string) $documentId);
+                $redis->del($deletedDocKey);
+                $redis->sRem($idxKey, \strtolower((string) $documentId));
+            }
 
-        $this->tx(fn (RedisClient $client) => $client->sAdd($dbsKey, $name));
+            foreach ($permissionIds as $permissionId) {
+                $documentId = (string) $permissionId;
+                if (isset($deleted[$documentId])) {
+                    continue;
+                }
+                $this->clearPermissions($collection, $documentId);
+            }
 
-        return true;
+            return \count($deleted);
+        });
     }
 
-    public function exists(string $database, ?string $collection = null): bool
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array
     {
-        $database = $this->filter($database);
-        $dbsKey = $this->key($this->nsBase(), 'dbs');
+        $collectionId = $this->filter($collection->getId());
+        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
 
-        if ((bool) $this->client->sIsMember($dbsKey, $database) === false) {
-            return false;
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
         }
 
-        if ($collection === null) {
-            return true;
-        }
+        return $this->tx(function (RedisClient $client) use ($collectionId, $queries, $limit, $offset, $orderAttributes, $orderTypes, $cursor, $cursorDirection, $forPermission): array {
+            $documents = $this->loadCollectionDocuments($client, $collectionId, $forPermission);
+            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
+            $documents = $this->orderDocuments($documents, $orderAttributes, $orderTypes, $cursorDirection);
+            $documents = $this->cursorDocuments($documents, $orderAttributes, $orderTypes, $cursor, $cursorDirection);
 
-        $collection = $this->filter($collection);
-        $namespace = $this->getNamespace();
-        $colsKey = $this->key($this->nsFor($namespace, $database), 'cols');
+            if (! \is_null($offset)) {
+                $documents = \array_slice($documents, $offset);
+            }
+            if (! \is_null($limit)) {
+                $documents = \array_slice($documents, 0, $limit);
+            }
 
-        return (bool) $this->client->sIsMember($colsKey, $collection);
+            $selections = $this->extractSelections($queries);
+            if (! empty($selections)) {
+                $projected = [];
+                foreach ($documents as $document) {
+                    $projected[] = $this->projectDocument($document, $selections);
+                }
+                $documents = $projected;
+            }
+
+            if ($cursorDirection === CursorDirection::Before) {
+                $documents = \array_reverse($documents);
+            }
+
+            return $documents;
+        });
     }
 
-    public function list(): array
+    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int
     {
-        $dbsKey = $this->key($this->nsBase(), 'dbs');
-        /** @var array<int, string>|false $names */
-        $names = $this->client->sMembers($dbsKey);
-        if ($names === false) {
-            $names = [];
-        }
+        $collectionId = $this->filter($collection->getId());
+        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
 
-        $databases = [];
-        foreach ($names as $name) {
-            $databases[] = new Document(['name' => $name]);
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
         }
 
-        return $databases;
-    }
-
-    public function delete(string $name): bool
-    {
-        $name = $this->filter($name);
-        $namespace = $this->getNamespace();
-        $dbsKey = $this->key($this->nsBase(), 'dbs');
-        $colsKey = $this->key($this->nsFor($namespace, $name), 'cols');
+        return $this->tx(function (RedisClient $client) use ($collectionId, $attribute, $queries, $max): float|int {
+            $documents = $this->loadCollectionDocuments($client, $collectionId, PermissionType::Read);
+            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
 
-        $this->tx(function (RedisClient $client) use ($name, $namespace, $dbsKey, $colsKey): void {
-            /** @var array<int, string>|false $collections */
-            $collections = $client->sMembers($colsKey);
-            if (\is_array($collections)) {
-                foreach ($collections as $collection) {
-                    $this->purgeCollectionKeys($client, $namespace, $name, $collection);
-                }
+            if (! \is_null($max)) {
+                $documents = \array_slice($documents, 0, $max);
             }
 
-            $client->del($colsKey);
-            $client->sRem($dbsKey, $name);
-        });
+            $sum = 0;
+            $isFloat = false;
+            foreach ($documents as $document) {
+                $value = $this->resolveDocumentAttribute($document, $attribute);
+                if ($value === null) {
+                    continue;
+                }
+                if (\is_float($value)) {
+                    $isFloat = true;
+                }
+                if (\is_numeric($value)) {
+                    $sum += $value;
+                }
+            }
 
-        return true;
+            return $isFloat ? (float) $sum : (int) $sum;
+        });
     }
 
-    public function createCollection(string $name, array $attributes = [], array $indexes = []): bool
+    public function count(Document $collection, array $queries = [], ?int $max = null): int
     {
-        $id = $this->filter($name);
-        $colsKey = $this->key($this->ns(), 'cols');
-        $metaKey = $this->key($this->ns(), 'meta', $id);
-        $idxKey = $this->idxKey($id);
+        $collectionId = $this->filter($collection->getId());
+        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
 
-        if ((bool) $this->client->exists($metaKey)) {
-            throw new DuplicateException('Collection already exists');
+        if ((bool) $this->client->exists($metaKey) === false) {
+            throw new NotFoundException('Collection not found');
         }
 
-        $attributePayload = [];
-        foreach ($attributes as $attribute) {
-            $attributePayload[] = $attribute->getArrayCopy();
-        }
-        $indexPayload = [];
-        foreach ($indexes as $index) {
-            $indexPayload[] = $index->getArrayCopy();
+        if (
+            empty($queries)
+            && $this->authorization->getStatus() === false
+            && $this->getSharedTables() === false
+        ) {
+            $idxKey = $this->idxKey($collectionId);
+            $cardinality = $this->client->sCard($idxKey);
+            if (\is_int($cardinality)) {
+                return $max === null ? $cardinality : \min($max, $cardinality);
+            }
         }
 
-        $schema = new Document([
-            '$id' => $id,
-            'name' => $name,
-            'attributes' => $attributePayload,
-            'indexes' => $indexPayload,
-        ]);
+        return $this->tx(function (RedisClient $client) use ($collectionId, $queries, $max): int {
+            $documents = $this->loadCollectionDocuments($client, $collectionId, PermissionType::Read);
+            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
 
-        $this->tx(function (RedisClient $client) use ($id, $colsKey, $metaKey, $idxKey, $schema, $attributePayload, $indexPayload): void {
-            $client->hMSet($metaKey, [
-                'schema' => \json_encode($schema->getArrayCopy(), JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-                'attrs' => \json_encode($attributePayload, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-                'indexes' => \json_encode($indexPayload, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-                'docCount' => '0',
-                'sizeBytes' => '0',
-            ]);
-            // Reserve the doc-id index set so SCAN/list operations work even
-            // before the first document write. Redis cannot persist empty
-            // sets, so we materialise the key on first write — but we still
-            // delete it on collection drop to clean up any prior contents.
-            $client->del($idxKey);
-            $client->sAdd($colsKey, $id);
-        });
+            if (! \is_null($max)) {
+                $documents = \array_slice($documents, 0, $max);
+            }
 
-        return true;
+            return \count($documents);
+        });
     }
 
-    public function deleteCollection(string $id): bool
+    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float|string $value, string $updatedAt, int|float|string|null $min = null, int|float|string|null $max = null): bool
     {
-        $id = $this->filter($id);
-        $namespace = $this->getNamespace();
-        $database = $this->getDatabase();
-        $colsKey = $this->key($this->ns(), 'cols');
+        $collection = $this->filter($collection);
+        $docKey = $this->docKey($collection, $id);
 
-        $this->tx(function (RedisClient $client) use ($id, $namespace, $database, $colsKey): void {
-            $this->purgeCollectionKeys($client, $namespace, $database, $id);
-            $client->sRem($colsKey, $id);
-        });
+        return $this->tx(function (RedisClient $redis) use ($collection, $id, $attribute, $value, $updatedAt, $min, $max, $docKey): bool {
+            $payload = $redis->get($docKey);
+            if (! \is_string($payload) || $payload === '') {
+                throw new NotFoundException('Document not found');
+            }
 
-        return true;
+            $document = $this->decode($payload);
+            $current = $document->getAttribute($attribute);
+            $exact = (\is_int($current) || (\is_string($current) && BigInt::isIntegerString($current)))
+                && (\is_int($value) || (\is_string($value) && BigInt::isIntegerString($value)));
+            if ($exact) {
+                $current = BigInt::toNative($current);
+                $value = BigInt::toNative($value);
+                if (! \is_null($min) && BigInt::compare($current, $min) < 0) {
+                    return true;
+                }
+                if (! \is_null($max) && BigInt::compare($current, $max) > 0) {
+                    return true;
+                }
+                $result = BigInt::add($current, $value);
+            } else {
+                $current = $this->numericOr($current, 0);
+                $value = $this->numericOr($value, 0);
+                if (! \is_null($min) && $current < $min) {
+                    return true;
+                }
+                if (! \is_null($max) && $current > $max) {
+                    return true;
+                }
+                $result = $current + $value;
+            }
+
+            $document->setAttribute($attribute, $result);
+            $document->setAttribute(Document::UPDATED_AT, $updatedAt);
+
+            $redis->set($docKey, $this->encode($document));
+
+            $this->journal('updateDoc', [
+                'collection' => $collection,
+                'id' => $id,
+                'newId' => $id,
+                'payload' => $payload,
+                'docKey' => $docKey,
+            ]);
+
+            return true;
+        });
     }
 
-    public function analyzeCollection(string $collection): bool
+    public function getLimitForString(): int
     {
-        // Redis maintains no internal table statistics; mirrors Memory's
-        // behavior for adapters without a stats subsystem.
-        return false;
+        return 4294967295;
     }
 
-    public function getSizeOfCollection(string $collection): int
+    public function getLimitForInt(): int
     {
-        return $this->computeCollectionSize($collection);
+        return 4294967295;
     }
 
-    public function getSizeOfCollectionOnDisk(string $collection): int
+    public function getLimitForBigInt(): int
     {
-        // Redis stores the working set in memory; on-disk size mirrors
-        // logical size for the purposes of the size-tracking tests.
-        return $this->computeCollectionSize($collection);
+        return Database::MAX_BIG_INT;
     }
 
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
+    public function getLimitForAttributes(): int
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $this->tx(function (RedisClient $client) use ($metaKey, $id, $type, $size, $signed, $array, $required): void {
-            $attrs = $this->readAttributesField($client, $metaKey);
-            $attrs = $this->upsertAttributeRecord($attrs, [
-                '$id' => $id,
-                'key' => $id,
-                'type' => $type,
-                'size' => $size,
-                'signed' => $signed,
-                'array' => $array,
-                'required' => $required,
-            ]);
-            $client->hSet(
-                $metaKey,
-                'attrs',
-                \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
-        });
-
-        return true;
+        return 1017;
     }
 
-    public function createAttributes(string $collection, array $attributes): bool
+    public function getLimitForIndexes(): int
     {
-        foreach ($attributes as $attribute) {
-            $this->createAttribute(
-                $collection,
-                (string) $attribute['$id'],
-                (string) $attribute['type'],
-                (int) ($attribute['size'] ?? 0),
-                (bool) ($attribute['signed'] ?? true),
-                (bool) ($attribute['array'] ?? false),
-                (bool) ($attribute['required'] ?? false),
-            );
-        }
-
-        return true;
+        return 64;
     }
 
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
+    public function getMaxIndexLength(): int
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
-        }
+        return 1024;
+    }
 
-        if (! empty($newKey) && $newKey !== $id) {
-            $this->renameAttribute($collection, $id, $newKey);
-            $id = $this->filter($newKey);
-        }
+    public function getMaxVarcharLength(): int
+    {
+        return 16381;
+    }
 
-        $this->tx(function (RedisClient $client) use ($metaKey, $id, $type, $size, $signed, $array, $required): void {
-            $attrs = $this->readAttributesField($client, $metaKey);
-            $attrs = $this->upsertAttributeRecord($attrs, [
-                '$id' => $id,
-                'key' => $id,
-                'type' => $type,
-                'size' => $size,
-                'signed' => $signed,
-                'array' => $array,
-                'required' => $required,
-            ]);
-            $client->hSet(
-                $metaKey,
-                'attrs',
-                \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
-        });
+    public function getMaxUIDLength(): int
+    {
+        return 255;
+    }
 
-        return true;
+    public function getMinDateTime(): \DateTime
+    {
+        return new \DateTime('0001-01-01 00:00:00');
     }
 
-    public function deleteAttribute(string $collection, string $id): bool
+    public function getIdAttributeType(): string
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
+        return ColumnType::Integer->value;
+    }
 
-        if ((bool) $this->client->exists($metaKey) === false) {
-            return true;
-        }
+    public function getCountOfAttributes(Document $collection): int
+    {
+        $attributes = $collection->getAttribute('attributes', []);
 
-        $this->tx(function (RedisClient $client) use ($metaKey, $id): void {
-            $attrs = $this->readAttributesField($client, $metaKey);
-            $filtered = [];
-            foreach ($attrs as $attribute) {
-                $existingId = (string) ($attribute['$id'] ?? $attribute['key'] ?? '');
-                if ($this->filter($existingId) === $id) {
-                    continue;
-                }
-                $filtered[] = $attribute;
-            }
-            $client->hSet(
-                $metaKey,
-                'attrs',
-                \json_encode($filtered, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
-        });
+        return (\is_array($attributes) ? \count($attributes) : 0) + $this->getCountOfDefaultAttributes();
+    }
 
-        $this->dropDocumentField($collection, $id);
+    public function getCountOfIndexes(Document $collection): int
+    {
+        $indexes = $collection->getAttribute('indexes', []);
 
-        return true;
+        return (\is_array($indexes) ? \count($indexes) : 0) + $this->getCountOfDefaultIndexes();
     }
 
-    public function renameAttribute(string $collection, string $old, string $new): bool
+    public function getCountOfDefaultAttributes(): int
     {
-        $collection = $this->filter($collection);
-        $old = $this->filter($old);
-        $new = $this->filter($new);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
-        }
+        return \count(Database::INTERNAL_ATTRIBUTES);
+    }
 
-        $this->tx(function (RedisClient $client) use ($metaKey, $old, $new): void {
-            $attrs = $this->readAttributesField($client, $metaKey);
-            $touched = false;
-            foreach ($attrs as $i => $attribute) {
-                $existingId = (string) ($attribute['$id'] ?? $attribute['key'] ?? '');
-                if ($this->filter($existingId) !== $old) {
-                    continue;
-                }
-                $attribute['$id'] = $new;
-                $attribute['key'] = $new;
-                $attrs[$i] = $attribute;
-                $touched = true;
-            }
-            if (! $touched) {
-                return;
-            }
-            $client->hSet(
-                $metaKey,
-                'attrs',
-                \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
-        });
+    public function getCountOfDefaultIndexes(): int
+    {
+        return \count(Database::INTERNAL_INDEXES);
+    }
 
-        $this->renameDocumentField($collection, $old, $new);
+    public function getDocumentSizeLimit(): int
+    {
+        return 0;
+    }
 
-        return true;
+    public function getAttributeWidth(Document $collection): int
+    {
+        return 0;
     }
 
-    public function getSchemaAttributes(string $collection): array
+    public function getKeywords(): array
     {
         return [];
     }
 
-    public function getCountOfAttributes(Document $collection): int
+    public function getInternalIndexesKeys(): array
     {
-        return \count($collection->getAttribute('attributes', [])) + $this->getCountOfDefaultAttributes();
+        return [];
     }
 
-    /**
-     * Read and decode the `attrs` JSON field on a collection meta hash. Returns
-     * a plain list of attribute record arrays (empty when the field is absent
-     * or stored empty).
-     *
-     * @return array<int, array<string, mixed>>
-     */
-    private function readAttributesField(RedisClient $client, string $metaKey): array
+    public function getTenantQuery(string $collection, string $alias = ''): string
     {
-        $raw = $client->hGet($metaKey, 'attrs');
-        if (! \is_string($raw) || $raw === '') {
-            return [];
-        }
-        /** @var array<int, array<string, mixed>> $decoded */
-        $decoded = \json_decode($raw, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
+        return '';
+    }
 
-        return \array_values($decoded);
+    public function setSupportForAttributes(bool $support): bool
+    {
+        $this->supportForAttributes = $support;
+
+        return $this->supportForAttributes;
+    }
+
+    #[\Override]
+    public function getConnectionId(): string
+    {
+        return '0';
     }
 
     /**
-     * Pre-flight unique-index check: scan the collection's existing rows for
-     * conflicts with `$document` against every UNIQUE index on the collection,
-     * mirroring Memory's `checkUniqueSignatures`. Throws DuplicateException
-     * on the first collision so callers don't waste a write round trip when
-     * MariaDB would have rejected the row.
-     *
-     * `$excludeId` lets `updateDocument` skip the document being updated.
+     * @param array<int, string> $selections
      */
-    private function enforceUniqueIndexes(RedisClient $client, string $collection, Document $document, ?string $excludeId = null): void
+    protected function getAttributeProjection(array $selections, string $prefix): mixed
     {
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-        $indexes = $this->readIndexesField($client, $metaKey);
-
-        $uniqueIndexes = [];
-        foreach ($indexes as $index) {
-            if (($index['type'] ?? '') !== Database::INDEX_UNIQUE) {
-                continue;
-            }
-            $attributes = $index['attributes'] ?? [];
-            if (empty($attributes)) {
-                continue;
-            }
-            $uniqueIndexes[] = $attributes;
-        }
+        return $selections;
+    }
 
-        if ($uniqueIndexes === []) {
-            return;
-        }
+    protected function execute(mixed $stmt): bool
+    {
+        return true;
+    }
 
-        // Build the new document's signatures up-front. Indexes that have any
-        // null component are treated as distinct (mirrors MariaDB's UNIQUE
-        // semantics — NULL never collides with another NULL).
-        $newSignatures = [];
-        $sharedTables = $this->getSharedTables();
-        $tenant = $sharedTables ? ($document->getAttribute('$tenant') ?? $this->getTenant()) : null;
-        foreach ($uniqueIndexes as $i => $attributes) {
-            $signature = [];
-            $hasNull = false;
-            foreach ($attributes as $attribute) {
-                $value = $this->resolveDocumentAttribute($document, (string) $attribute);
-                if ($value === null) {
-                    $hasNull = true;
-                    break;
-                }
-                $signature[] = $this->normalizeIndexValue($value);
-            }
-            if ($hasNull) {
-                continue;
-            }
-            if ($sharedTables) {
-                \array_unshift($signature, $tenant);
-            }
-            $newSignatures[$i] = \serialize($signature);
-        }
+    protected function quote(string $string): string
+    {
+        return '"'.$string.'"';
+    }
 
-        if ($newSignatures === []) {
-            return;
-        }
+    private function key(string ...$parts): string
+    {
+        return \implode(self::SEP, $parts);
+    }
 
-        $idxKey = $this->idxKey($collection);
-        /** @var array<int, string> $docIds */
-        $docIds = $client->sMembers($idxKey);
-        if (empty($docIds)) {
-            return;
-        }
+    private function ns(): string
+    {
+        return $this->nsFor($this->getNamespace(), $this->getDatabase());
+    }
 
-        $excludeKey = $excludeId !== null ? \strtolower($excludeId) : null;
-        $docKeys = [];
-        foreach ($docIds as $docId) {
-            if ($excludeKey !== null && \strtolower((string) $docId) === $excludeKey) {
-                continue;
-            }
-            $docKeys[(string) $docId] = $this->docKey($collection, (string) $docId);
-        }
-        if ($docKeys === []) {
-            return;
-        }
+    private function nsFor(string $namespace, string $database): string
+    {
+        return self::KEY_PREFIX.self::SEP.$namespace.self::SEP.$database;
+    }
 
-        /** @var array<int, mixed> $payloads */
-        $payloads = $client->mGet(\array_values($docKeys));
-        $position = 0;
-        foreach ($docKeys as $docId => $_) {
-            $payload = $payloads[$position++] ?? null;
-            if (! \is_string($payload) || $payload === '') {
-                continue;
-            }
-            $existing = $this->decode($payload);
-            if ($sharedTables) {
-                $rowTenant = $existing->getAttribute('$tenant');
-                if ($rowTenant !== $tenant) {
-                    continue;
-                }
-            }
-            foreach ($newSignatures as $i => $newHash) {
-                $attributes = $uniqueIndexes[$i];
-                $signature = [];
-                $hasNull = false;
-                foreach ($attributes as $attribute) {
-                    $value = $this->resolveDocumentAttribute($existing, (string) $attribute);
-                    if ($value === null) {
-                        $hasNull = true;
-                        break;
-                    }
-                    $signature[] = $this->normalizeIndexValue($value);
-                }
-                if ($hasNull) {
-                    continue;
-                }
-                if ($sharedTables) {
-                    \array_unshift($signature, $tenant);
-                }
-                if (\serialize($signature) === $newHash) {
-                    throw new UniqueException('Unique index violation');
-                }
-            }
-        }
+    private function nsBase(): string
+    {
+        return self::KEY_PREFIX.self::SEP.$this->getNamespace();
     }
 
-    /**
-     * Insert or replace an attribute record matched by `$id`/`key`. Returns a
-     * fresh list (re-indexed) so the JSON encodes as an array, never an object.
-     *
-     * @param array<int, array<string, mixed>> $attrs
-     * @param array<string, mixed> $record
-     * @return array<int, array<string, mixed>>
-     */
-    private function upsertAttributeRecord(array $attrs, array $record): array
+    private function docKey(string $collection, string $id, int|string|null $tenant = null): string
     {
-        $targetId = (string) ($record['$id'] ?? '');
-        $replaced = false;
-        foreach ($attrs as $i => $existing) {
-            $existingId = (string) ($existing['$id'] ?? $existing['key'] ?? '');
-            if ($existingId !== $targetId) {
-                continue;
-            }
-            $attrs[$i] = $record;
-            $replaced = true;
-            break;
-        }
-        if (! $replaced) {
-            $attrs[] = $record;
+        $id = \strtolower($id);
+        if (! $this->getSharedTables()) {
+            return $this->key($this->ns(), 'doc', $collection, $id);
         }
 
-        return \array_values($attrs);
+        $bucket = $this->bucketFor($tenant);
+
+        return $this->key($this->ns(), 'doc', 't', $bucket, $collection, $id);
     }
 
-    /**
-     * Drop every key associated with a single collection inside `{ns}:{db}`.
-     * Used by both deleteCollection and the cascading delete() path. Permission
-     * sets and document blobs are SCANned because we can't enumerate them
-     * without an index — the doc-id set under `idx:{col}` is authoritative for
-     * existing documents but permission roles vary, so we SCAN the prefix.
-     */
-    private function purgeCollectionKeys(RedisClient $client, string $namespace, string $database, string $collection): void
+    private function idxKey(string $collection, int|string|null $tenant = null): string
     {
-        $collection = $this->filter($collection);
-        $prefix = $this->nsFor($namespace, $database);
-        $metaKey = $this->key($prefix, 'meta', $collection);
-        $idxKey = $this->key($prefix, 'idx', $collection);
-        $seqKey = $this->key($prefix, 'seq', $collection);
-
-        // Non-shared layout: walk the doc-id index for variadic DEL of every
-        // doc + perm-doc HASH. Cheap when the set is empty.
-        /** @var array<int, string>|false $docIds */
-        $docIds = $client->sMembers($idxKey);
-        if (\is_array($docIds) && $docIds !== []) {
-            $keys = [];
-            foreach ($docIds as $docId) {
-                $keys[] = $this->key($prefix, 'doc', $collection, $docId);
-                $keys[] = $this->key($prefix, 'perm', 'doc', $collection, $docId);
-                if (\count($keys) >= self::SCAN_BATCH_SIZE) {
-                    $client->del(...$keys);
-                    $keys = [];
-                }
-            }
-            if ($keys !== []) {
-                $client->del(...$keys);
-            }
+        if (! $this->getSharedTables()) {
+            return $this->key($this->ns(), 'idx', $collection);
         }
 
-        // Shared-tables doc/idx/seq sweep: tenants-bucketed under
-        // `{prefix}:doc:t:{tenant}:{col}:*`, `{prefix}:idx:t:{tenant}:{col}`
-        // and `{prefix}:seq:t:{tenant}:{col}`. Run unconditionally so a
-        // collection populated while shared-tables was on can still be
-        // purged after the test resets the flag back off.
-        $this->deleteByPattern($client, $prefix . self::SEP . 'doc' . self::SEP . 't' . self::SEP . '*' . self::SEP . $collection . self::SEP . '*');
-        $this->deleteByPattern($client, $prefix . self::SEP . 'idx' . self::SEP . 't' . self::SEP . '*' . self::SEP . $collection);
-        $this->deleteByPattern($client, $prefix . self::SEP . 'seq' . self::SEP . 't' . self::SEP . '*' . self::SEP . $collection);
-
-        // Non-shared-tables perm-set sweep. permKey() emits this layout when
-        // shared tables is OFF: `{prefix}:perm:{col}:{letter}:{role}`.
-        $this->deleteByPattern($client, $this->key($prefix, 'perm', $collection) . self::SEP . '*');
-        // Shared-tables perm sweep. permKey()/permDocKey() emit
-        // `{prefix}:perm:t:{tenant}:{col}:...` and
-        // `{prefix}:perm:t:{tenant}:doc:{col}:...` respectively. The non-shared
-        // pattern above does NOT match these, so without this sweep dropping a
-        // collection under shared tables leaves stale role/doc HASH keys
-        // behind — and a recreated collection inherits stale grants.
-        $this->deleteByPattern($client, $prefix . self::SEP . 'perm' . self::SEP . 't' . self::SEP . '*' . self::SEP . $collection . self::SEP . '*');
-        $this->deleteByPattern($client, $prefix . self::SEP . 'perm' . self::SEP . 't' . self::SEP . '*' . self::SEP . 'doc' . self::SEP . $collection . self::SEP . '*');
-        $this->deleteByPattern($client, $this->key($prefix, 'tenants', $collection) . self::SEP . '*');
-
-        $client->del($metaKey, $idxKey, $seqKey);
+        return $this->key($this->ns(), 'idx', 't', $this->bucketFor($tenant), $collection);
     }
 
-    /**
-     * SCAN-and-DEL helper — MATCHes the supplied glob in batches so we don't
-     * block the server with a giant KEYS call. Honours the same 500-key batch
-     * size used by the test harness teardown.
-     */
-    private function deleteByPattern(RedisClient $client, string $pattern): void
+    private function seqKey(string $collection, int|string|null $tenant = null): string
     {
-        $cursor = null;
-        do {
-            /** @var array<int, string>|false $batch */
-            $batch = $client->scan($cursor, $pattern, self::SCAN_BATCH_SIZE);
-            if (\is_array($batch) && $batch !== []) {
-                $client->del(...$batch);
-            }
-        } while ($cursor !== 0 && $cursor !== null);
+        if (! $this->getSharedTables()) {
+            return $this->key($this->ns(), 'seq', $collection);
+        }
+
+        return $this->key($this->ns(), 'seq', 't', $this->bucketFor($tenant), $collection);
     }
 
-    /**
-     * Compute the size of a collection by summing memory used by its meta
-     * hash, every document blob, the doc-id index, and any permission sets.
-     *
-     * Redis `MEMORY USAGE` is used when supported (Redis 4.0+). We fall back
-     * to STRLEN/HLEN approximations so the adapter still produces a non-zero
-     * size on builds (or test doubles) where MEMORY USAGE isn't routed.
-     */
-    private function computeCollectionSize(string $collection): int
+    private function bucketFor(int|string|null $tenant): string
     {
-        $collection = $this->filter($collection);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            return 0;
+        if ($tenant === null) {
+            $tenant = $this->getTenant();
         }
 
-        $total = $this->measureKey($metaKey);
-
-        $idxKey = $this->idxKey($collection);
-        $total += $this->measureKey($idxKey);
+        return $tenant === null ? '_' : (string) $tenant;
+    }
 
-        /** @var array<int, string>|false $docIds */
-        $docIds = $this->client->sMembers($idxKey);
-        if (\is_array($docIds)) {
-            foreach ($docIds as $docId) {
-                $total += $this->measureKey($this->docKey($collection, (string) $docId));
-                // Route through permDocKey() so the tenant-bucketed shape is
-                // honoured under shared tables; otherwise the per-document
-                // perm HASH is missed entirely.
-                $total += $this->measureKey($this->permDocKey($collection, (string) $docId));
-            }
+    private function tenantBucket(): ?string
+    {
+        if (! $this->getSharedTables()) {
+            return null;
         }
+        $tenant = $this->getTenant();
+
+        return $tenant === null ? '_' : (string) $tenant;
+    }
 
-        // Inverted permission SETs live under permKey()'s shape — tenant
-        // bucketed under shared tables, flat otherwise. Pick the matching
-        // SCAN prefix so both layouts contribute to the size estimate.
+    private function permKey(string $collection, string $letter, string $role): string
+    {
         $bucket = $this->tenantBucket();
         if ($bucket !== null) {
-            $permPrefix = $this->ns() . self::SEP . 'perm' . self::SEP . 't' . self::SEP . $bucket . self::SEP . $collection . self::SEP . '*';
-        } else {
-            $permPrefix = $this->key($this->ns(), 'perm', $collection) . self::SEP . '*';
+            return $this->ns().self::SEP.'perm'.self::SEP.'t'.self::SEP.$bucket.self::SEP.$collection.self::SEP.$letter.self::SEP.$role;
         }
-        $cursor = null;
-        do {
-            /** @var array<int, string>|false $batch */
-            $batch = $this->client->scan($cursor, $permPrefix, self::SCAN_BATCH_SIZE);
-            if (\is_array($batch)) {
-                foreach ($batch as $key) {
-                    $total += $this->measureKey($key);
-                }
-            }
-        } while ($cursor !== 0 && $cursor !== null);
 
-        return $total;
+        return $this->ns().self::SEP.'perm'.self::SEP.$collection.self::SEP.$letter.self::SEP.$role;
     }
 
-    /**
-     * Best-effort size probe for a single Redis key. Prefers `MEMORY USAGE`
-     * (returns the bytes Redis itself reports). Falls back to the encoded
-     * payload length when MEMORY USAGE is unavailable, so the result remains
-     * a stable monotonically-growing integer for size-tracking tests.
-     */
-    private function measureKey(string $key): int
+    private function permDocKey(string $collection, string $id): string
     {
-        try {
-            /** @var int|false|null $usage */
-            $usage = $this->client->rawCommand('MEMORY', 'USAGE', $key);
-            if (\is_int($usage)) {
-                return $usage;
-            }
-        } catch (\Throwable) {
-            // Fall through to the structural fallback below.
+        $id = \strtolower($id);
+        $bucket = $this->tenantBucket();
+        if ($bucket !== null) {
+            return $this->ns().self::SEP.'perm'.self::SEP.'t'.self::SEP.$bucket.self::SEP.'doc'.self::SEP.$collection.self::SEP.$id;
         }
 
-        $type = $this->client->type($key);
-        switch ($type) {
-            case RedisClient::REDIS_STRING:
-                $value = $this->client->get($key);
-
-                return \is_string($value) ? \strlen($value) + \strlen($key) : 0;
-            case RedisClient::REDIS_HASH:
-                $entries = $this->client->hGetAll($key);
-                $bytes = \strlen($key);
-                if (\is_array($entries)) {
-                    foreach ($entries as $field => $value) {
-                        $bytes += \strlen((string) $field) + \strlen((string) $value);
-                    }
-                }
-
-                return $bytes;
-            case RedisClient::REDIS_SET:
-                $members = $this->client->sMembers($key);
-                $bytes = \strlen($key);
-                if (\is_array($members)) {
-                    foreach ($members as $member) {
-                        $bytes += \strlen((string) $member);
-                    }
-                }
-
-                return $bytes;
-            default:
-                return 0;
-        }
+        return $this->ns().self::SEP.'perm'.self::SEP.'doc'.self::SEP.$collection.self::SEP.$id;
     }
 
-    // === @architect:T20 end ===
-
-
-
-
-
-    // === @architect:T30 owns: document CRUD + bulk + increase ===
+    private function encode(Document $document): string
+    {
+        return \json_encode(
+            $document->getArrayCopy(),
+            JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION
+        );
+    }
 
-    public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
+    private function decode(string $payload): Document
     {
-        $col = $this->filter($collection->getId());
-        $payload = $this->client->get($this->docKey($col, $id));
-        // Mirror Memory's METADATA fallback: under shared tables the
-        // bootstrap METADATA row is written with a null tenant and must
-        // be visible to every tenant.
-        if ((! \is_string($payload) || $payload === '') && $this->getSharedTables() && $col === Database::METADATA) {
-            $payload = $this->client->get($this->docKey($col, $id, '_'));
+        try {
+            /** @var array<string, mixed> $data */
+            $data = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
+        } catch (\JsonException $e) {
+            throw new DatabaseException('Document decode failed: '.$e->getMessage(), 0, $e);
         }
 
-        if (! \is_string($payload) || $payload === '') {
-            return new Document([]);
+        return new Document($data);
+    }
+
+    /**
+     * @template T
+     * @param callable(RedisClient): T $fn
+     * @return T
+     */
+    protected function tx(callable $fn): mixed
+    {
+        try {
+            return $fn($this->client);
+        } catch (\RedisException $exception) {
+            throw new TransactionException('tx failed: '.$exception->getMessage(), 0, $exception);
         }
+    }
 
-        $document = $this->decode($payload);
+    private function writePermissions(string $collection, string $id, Document $document): void
+    {
+        $id = \strtolower($id);
 
-        // Mirror the loadCollectionDocuments tenant filter: under shared
-        // tables a doc key written for tenant A must not surface for tenant
-        // B. Permission filtering can't catch this on the single-doc path
-        // because the caller already knows the id. METADATA collections
-        // are exempt — they intentionally serve null-tenant rows to every
-        // tenant.
-        if ($this->getSharedTables()) {
-            $rowTenant = $document->getAttribute('$tenant');
-            $tenant = $this->getTenant();
-            $allowNullTenant = $col === Database::METADATA && $rowTenant === null;
-            if (! $allowNullTenant && $rowTenant !== $tenant) {
-                return new Document([]);
+        $byRole = [];
+        foreach ([PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete] as $type) {
+            foreach ($document->getPermissionsByType($type) as $role) {
+                $byRole[(string) $role][] = $this->actionLetter($type);
             }
         }
 
-        if ($col !== Database::METADATA) {
-            $document = $this->surfaceRelationshipAttributes($col, $document);
+        if ($byRole === []) {
+            return;
         }
 
-        $selections = [];
-        foreach ($queries as $query) {
-            if ($query instanceof Query && $query->getMethod() === Query::TYPE_SELECT) {
-                foreach ($query->getValues() as $value) {
-                    $selections[] = (string) $value;
-                }
+        $hashKey = $this->permDocKey($collection, $id);
+        $hashFields = [];
+        $writes = [];
+        foreach ($byRole as $role => $letters) {
+            $unique = \array_values(\array_unique($letters));
+            \sort($unique);
+            $hashFields[$role] = \implode(',', $unique);
+            foreach ($unique as $letter) {
+                $writes[] = [$role, $letter];
             }
         }
 
-        if (! empty($selections) && ! \in_array('*', $selections, true)) {
-            $projected = [];
-            foreach ($document->getArrayCopy() as $field => $value) {
-                if (\str_starts_with((string) $field, '$') || \str_starts_with((string) $field, '_')) {
-                    $projected[$field] = $value;
-
-                    continue;
-                }
-                if (\in_array($field, $selections, true)) {
-                    $projected[$field] = $value;
-                }
+        $this->client->multi(\Redis::PIPELINE);
+        try {
+            foreach ($writes as [$role, $letter]) {
+                $this->client->sAdd($this->permKey($collection, $letter, $role), $id);
+            }
+            $this->client->hMSet($hashKey, $hashFields);
+            $this->client->exec();
+        } catch (\Throwable $e) {
+            try {
+                $this->client->discard();
+            } catch (\Throwable) {
+                // ignore
             }
-            $document = new Document($projected);
+            throw $e;
         }
 
-        return $document;
+        foreach ($writes as [$role, $letter]) {
+            $this->journal('createPerm', [
+                'collection' => $collection,
+                'id' => $id,
+                'role' => $role,
+                'letter' => $letter,
+            ]);
+        }
     }
 
-    public function createDocument(Document $collection, Document $document): Document
+    private function clearPermissions(string $collection, string $id): void
     {
-        $col = $this->filter($collection->getId());
-        $id = $document->getId();
-        if ($id === '') {
-            $id = ID::unique();
-            $document->setAttribute('$id', $id);
+        $id = \strtolower($id);
+        $hashKey = $this->permDocKey($collection, $id);
+        /** @var array<string, string>|false $hash */
+        $hash = $this->client->hGetAll($hashKey);
+        if ($hash === false || $hash === []) {
+            return;
         }
-        $tenant = $document->getTenant();
-        $docKey = $this->docKey($col, $id, $tenant);
-        $idxKey = $this->idxKey($col, $tenant);
-        $seqKey = $this->seqKey($col, $tenant);
-        $permDocKey = $this->permDocKey($col, $id);
-
-        return $this->tx(function (RedisClient $redis) use ($col, $id, $document, $docKey, $idxKey, $seqKey, $permDocKey): Document {
-            if ((bool) $redis->exists($docKey)) {
-                if ($this->skipDuplicates) {
-                    // Mirrors MariaDB's `INSERT IGNORE` and Memory's skipDuplicates path:
-                    // duplicate primary key is silently dropped and the existing row's
-                    // sequence is returned so the caller can still emit an onNext event.
-                    $existingPayload = $redis->get($docKey);
-                    if (\is_string($existingPayload) && $existingPayload !== '') {
-                        $existing = $this->decode($existingPayload);
-                        $document->setAttribute('$sequence', $existing->getSequence() ?? '');
-                    }
 
-                    return $document;
-                }
-                throw new DuplicateException('Document already exists');
+        $removals = [];
+        foreach ($hash as $role => $letterCsv) {
+            if ($letterCsv === '') {
+                continue;
             }
-
-            try {
-                $this->enforceUniqueIndexes($redis, $col, $document);
-            } catch (DuplicateException $e) {
-                if ($this->skipDuplicates) {
-                    return $document;
-                }
-                throw $e;
+            foreach (\explode(',', $letterCsv) as $letter) {
+                $removals[] = [$role, $letter];
             }
+        }
 
-            $sequence = $document->getSequence();
-            if (empty($sequence)) {
-                $next = $redis->incr($seqKey);
-                $sequence = (string) $next;
-            } else {
-                $sequence = (string) $sequence;
-                $current = $redis->get($seqKey);
-                if (! \is_string($current) || (int) $sequence > (int) $current) {
-                    $redis->set($seqKey, $sequence);
-                }
+        $this->client->multi(\Redis::PIPELINE);
+        try {
+            foreach ($removals as [$role, $letter]) {
+                $this->client->sRem($this->permKey($collection, $letter, $role), $id);
             }
-            $document->setAttribute('$sequence', $sequence);
-
-            $redis->set($docKey, $this->encode($document));
-            $redis->sAdd($idxKey, \strtolower($id));
+            $this->client->del($hashKey);
+            $this->client->exec();
+        } catch (\Throwable $e) {
+            try {
+                $this->client->discard();
+            } catch (\Throwable) {
+                // ignore
+            }
+            throw $e;
+        }
 
-            $this->writePermissions($col, $id, $document);
-            $this->journal('createDoc', [
-                'collection' => $col,
+        foreach ($removals as [$role, $letter]) {
+            $this->journal('deletePerm', [
+                'collection' => $collection,
                 'id' => $id,
-                'docKey' => $docKey,
-                'idxKey' => $idxKey,
-                'permDocKey' => $permDocKey,
+                'role' => $role,
+                'letter' => $letter,
+                'previous' => $hash[$role] ?? '',
             ]);
-
-            return $document;
-        });
+        }
     }
 
-    public function createDocuments(Document $collection, array $documents): array
+    /**
+     * @param array<int, string> $ids
+     * @return array<int, string>
+     */
+    private function applyPermissionFilter(string $collection, array $ids, PermissionType $action): array
     {
-        $created = [];
-        foreach ($documents as $document) {
-            $created[] = $this->createDocument($collection, $document);
+        if ($ids === []) {
+            return $ids;
+        }
+        if ($this->authorization->getStatus() === false) {
+            return $ids;
         }
 
-        return $created;
-    }
-
-    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
-    {
-        $col = $this->filter($collection->getId());
-        $oldKey = $this->docKey($col, $id);
-        $idxKey = $this->idxKey($col);
-        // METADATA fallback: under shared tables the bootstrap METADATA row
-        // is written with a null tenant; subsequent updates from another
-        // tenant must still resolve to that row instead of throwing.
-        $useNullTenant = false;
-        if ($col === Database::METADATA && $this->getSharedTables() && $this->getTenant() !== null) {
-            if ((bool) $this->client->exists($oldKey) === false) {
-                $oldKey = $this->docKey($col, $id, '_');
-                $useNullTenant = true;
-            }
+        $roles = $this->authorization->getRoles();
+        if ($roles === []) {
+            return [];
         }
 
-        return $this->tx(function (RedisClient $redis) use ($col, $id, $document, $skipPermissions, $oldKey, $idxKey, $useNullTenant): Document {
-            $existingPayload = $redis->get($oldKey);
-            if (! \is_string($existingPayload) || $existingPayload === '') {
-                throw new NotFoundException('Document not found');
-            }
+        $letter = $this->actionLetter($action);
+        $keys = [];
+        foreach ($roles as $role) {
+            $keys[] = $this->permKey($collection, $letter, $role);
+        }
 
-            $existing = $this->decode($existingPayload);
-            if ($col !== Database::METADATA) {
-                $existing = $this->surfaceRelationshipAttributes($col, $existing);
-            }
-            $newId = $document->getId() !== '' ? $document->getId() : $id;
-            // Stay on the null-tenant key when the existing row was located
-            // there; rewriting under the current tenant would split the row.
-            $newKey = $useNullTenant ? $this->docKey($col, $newId, '_') : $this->docKey($col, $newId);
-            // Idx set scoping mirrors the located row so per-tenant ids remain
-            // separate but the null-tenant METADATA row stays in the null
-            // tenant's idx set.
-            $effectiveIdxKey = $useNullTenant ? $this->idxKey($col, '_') : $idxKey;
+        if (\count($keys) === 1) {
+            /** @var array<int, string>|false $allowed */
+            $allowed = $this->client->sMembers($keys[0]);
+        } else {
+            $first = \array_shift($keys);
+            /** @var array<int, string>|false $allowed */
+            $allowed = $this->client->sUnion($first, ...$keys);
+        }
+        if ($allowed === false || $allowed === []) {
+            return [];
+        }
 
-            if ($newId !== $id && (bool) $redis->exists($newKey)) {
-                throw new DuplicateException('Document already exists');
-            }
+        $allowedSet = \array_flip($allowed);
 
-            $resolved = $this->applyOperators($document->getArrayCopy(), $existing->getArrayCopy());
-            $merged = \array_merge($existing->getArrayCopy(), $resolved);
-            $merged['$id'] = $newId;
-            $mergedDocument = new Document($merged);
+        return \array_values(\array_filter($ids, static fn (string $id): bool => isset($allowedSet[$id])));
+    }
 
-            $this->enforceUniqueIndexes($redis, $col, $mergedDocument, $id);
+    private function actionLetter(PermissionType $action): string
+    {
+        return match ($action) {
+            PermissionType::Read => 'r',
+            PermissionType::Create => 'c',
+            PermissionType::Update => 'u',
+            PermissionType::Delete => 'd',
+            PermissionType::Write => 'w',
+        };
+    }
 
-            $payload = $this->encode($mergedDocument);
+    /**
+     * @param array<string, mixed> $payload
+     */
+    protected function journal(string $op, array $payload): void
+    {
+        if ($this->inTransaction === 0) {
+            return;
+        }
+        $this->journalStack[\count($this->journalStack) - 1][] = [
+            'op' => $op,
+            'payload' => $payload,
+        ];
+    }
 
-            if ($newId !== $id) {
-                $redis->del($oldKey);
-                $redis->sRem($effectiveIdxKey, \strtolower($id));
-            }
-            $redis->set($newKey, $payload);
-            $redis->sAdd($effectiveIdxKey, \strtolower($newId));
+    /**
+     * @param array<string, mixed> $payload
+     */
+    private function payloadString(array $payload, string $key): ?string
+    {
+        $value = $payload[$key] ?? null;
 
-            $this->journal('updateDoc', [
-                'collection' => $col,
-                'id' => $id,
-                'newId' => $newId,
-                'payload' => $existingPayload,
-                'docKey' => $oldKey,
-                'newDocKey' => $newKey,
-                'idxKey' => $effectiveIdxKey,
-            ]);
+        return \is_string($value) ? $value : null;
+    }
 
-            if (! $skipPermissions) {
-                $this->clearPermissions($col, $id);
-                if ($newId !== $id) {
-                    $this->clearPermissions($col, $newId);
-                }
-                $this->writePermissions($col, $newId, $mergedDocument);
-            }
+    /**
+     * @param array<string, mixed> $payload
+     */
+    private function payloadStringOr(array $payload, string $key, string $default): string
+    {
+        $value = $payload[$key] ?? null;
 
-            return $mergedDocument;
-        });
+        return \is_string($value) ? $value : $default;
     }
 
-    public function updateDocuments(Document $collection, Document $updates, array $documents): int
+    private function stringOrEmpty(mixed $value): string
     {
-        if (empty($documents)) {
-            return 0;
-        }
+        return \is_string($value) ? $value : '';
+    }
 
-        $attrs = $updates->getAttributes();
-        $hasCreatedAt = ! empty($updates->getCreatedAt());
-        $hasUpdatedAt = ! empty($updates->getUpdatedAt());
-        $hasPermissions = $updates->offsetExists('$permissions');
-        if (empty($attrs) && ! $hasCreatedAt && ! $hasUpdatedAt && ! $hasPermissions) {
-            return 0;
-        }
+    private function numericOr(mixed $value, int|float $default): int|float
+    {
+        return \is_numeric($value) ? $value + 0 : $default;
+    }
 
-        $col = $this->filter($collection->getId());
+    private function intOr(mixed $value, int $default): int
+    {
+        return \is_numeric($value) ? (int) $value : $default;
+    }
 
-        // Drop any caller-provided keys: pipeline results are indexed
-        // sequentially, so positional iteration here MUST start at 0.
-        $documents = \array_values($documents);
+    /**
+     * @param array<string, mixed> $record
+     */
+    private function recordIdentifier(array $record): string
+    {
+        $id = $record[Document::ID] ?? null;
+        if (\is_string($id)) {
+            return $id;
+        }
+        $key = $record['key'] ?? null;
 
-        return $this->tx(function (RedisClient $redis) use ($col, $documents, $updates, $attrs, $hasCreatedAt, $hasUpdatedAt, $hasPermissions): int {
-            // Pipeline existing-payload GETs in a single round trip — mirrors
-            // upsertDocuments() and avoids one synchronous round trip per
-            // document, which dominates wall time on bulk updates.
-            $docKeys = [];
-            foreach ($documents as $doc) {
-                $docKeys[] = $this->docKey($col, $doc->getId());
-            }
+        return \is_string($key) ? $key : '';
+    }
 
-            $redis->multi(\Redis::PIPELINE);
-            foreach ($docKeys as $docKey) {
-                $redis->get($docKey);
-            }
-            $existingPayloads = $redis->exec();
-            if (! \is_array($existingPayloads)) {
-                $existingPayloads = [];
-            }
+    protected function rollbackJournal(): void
+    {
+        $frame = \array_pop($this->journalStack);
+        if ($frame === null) {
+            return;
+        }
 
-            // Cache the relationship-key list once per bulk call so the
-            // null-surface pass is N reads of a local list, not N reads of
-            // meta.attrs.
-            $relationshipKeys = [];
-            if ($col !== Database::METADATA) {
-                $metaKey = $this->key($this->ns(), 'meta', $this->filter($col));
-                $attributes = $this->readAttributesField($redis, $metaKey);
-                $relationshipKeys = $this->extractRelationshipKeys($attributes);
-            }
+        for ($i = \count($frame) - 1; $i >= 0; $i--) {
+            $entry = $frame[$i];
+            $op = $entry['op'];
+            $payload = $entry['payload'];
 
-            $count = 0;
-            foreach ($documents as $i => $doc) {
-                $uid = $doc->getId();
-                $docKey = $docKeys[$i];
-                $existingPayload = $existingPayloads[$i] ?? false;
-                if (! \is_string($existingPayload) || $existingPayload === '') {
-                    continue;
-                }
+            switch ($op) {
+                case 'createDoc':
+                    $collection = $this->payloadStringOr($payload, 'collection', '');
+                    $id = $this->payloadStringOr($payload, 'id', '');
+                    $this->rawDeleteDoc(
+                        $collection,
+                        $id,
+                        $this->payloadString($payload, 'docKey'),
+                        $this->payloadString($payload, 'idxKey'),
+                        $this->payloadString($payload, 'permDocKey'),
+                    );
+                    break;
 
-                $existing = $this->decode($existingPayload);
-                if (! empty($relationshipKeys)) {
-                    $existing = $this->surfaceRelationshipAttributesUsing($relationshipKeys, $existing);
-                }
-                $merged = $existing->getArrayCopy();
-                $resolved = $this->applyOperators($attrs, $merged);
-                foreach ($resolved as $attribute => $value) {
-                    $merged[$attribute] = $value;
-                }
-                if ($hasCreatedAt) {
-                    $merged['$createdAt'] = $updates->getCreatedAt();
-                }
-                if ($hasUpdatedAt) {
-                    $merged['$updatedAt'] = $updates->getUpdatedAt();
-                }
-                if ($hasPermissions) {
-                    $merged['$permissions'] = $updates->getPermissions();
-                }
+                case 'deleteDoc':
+                    $collection = $this->payloadStringOr($payload, 'collection', '');
+                    $id = $this->payloadStringOr($payload, 'id', '');
+                    $beforePayload = $this->payloadStringOr($payload, 'payload', '');
+                    $this->rawRestoreDoc(
+                        $collection,
+                        $id,
+                        $beforePayload,
+                        $this->payloadString($payload, 'docKey'),
+                        $this->payloadString($payload, 'idxKey'),
+                    );
+                    break;
 
-                $mergedDocument = new Document($merged);
-                $redis->set($docKey, $this->encode($mergedDocument));
+                case 'updateDoc':
+                    $collection = $this->payloadStringOr($payload, 'collection', '');
+                    $id = $this->payloadStringOr($payload, 'id', '');
+                    $beforePayload = $this->payloadStringOr($payload, 'payload', '');
+                    $docKey = $this->payloadString($payload, 'docKey') ?? $this->docKey($collection, $id);
+                    $this->client->set($docKey, $beforePayload);
+                    $newId = $this->payloadString($payload, 'newId');
+                    if ($newId !== null && $newId !== $id) {
+                        $newDocKey = $this->payloadString($payload, 'newDocKey') ?? $this->docKey($collection, $newId);
+                        $this->client->del($newDocKey);
+                        $idxKey = $this->payloadString($payload, 'idxKey') ?? $this->idxKey($collection);
+                        $this->client->sRem($idxKey, \strtolower($newId));
+                        $this->client->sAdd($idxKey, \strtolower($id));
+                    }
+                    break;
 
-                $this->journal('updateDoc', [
-                    'collection' => $col,
-                    'id' => $uid,
-                    'newId' => $uid,
-                    'payload' => $existingPayload,
-                    'docKey' => $docKey,
-                ]);
+                case 'createPerm':
+                    $collection = $this->payloadStringOr($payload, 'collection', '');
+                    $letter = $this->payloadStringOr($payload, 'letter', '');
+                    $role = $this->payloadStringOr($payload, 'role', '');
+                    $id = $this->payloadStringOr($payload, 'id', '');
+                    $this->client->sRem($this->permKey($collection, $letter, $role), $id);
+                    $this->client->hDel($this->permDocKey($collection, $id), $role);
+                    break;
 
-                if ($hasPermissions) {
-                    $this->clearPermissions($col, $uid);
-                    $this->writePermissions($col, $uid, $mergedDocument);
-                }
+                case 'deletePerm':
+                    $collection = $this->payloadStringOr($payload, 'collection', '');
+                    $letter = $this->payloadStringOr($payload, 'letter', '');
+                    $role = $this->payloadStringOr($payload, 'role', '');
+                    $id = $this->payloadStringOr($payload, 'id', '');
+                    $this->client->sAdd($this->permKey($collection, $letter, $role), $id);
+                    $previous = $this->payloadString($payload, 'previous');
+                    if ($previous !== null && $previous !== '') {
+                        $this->client->hSet($this->permDocKey($collection, $id), $role, $previous);
+                    }
+                    break;
 
-                $count++;
+                default:
+                    throw new TransactionException('Unknown journal op: '.$op);
             }
+        }
+    }
 
-            return $count;
-        });
+    private function rawDeleteDoc(string $collection, string $id, ?string $docKey = null, ?string $idxKey = null, ?string $permDocKey = null): void
+    {
+        $lowerId = \strtolower($id);
+        $this->client->del($docKey ?? $this->docKey($collection, $lowerId));
+        $this->client->sRem($idxKey ?? $this->idxKey($collection), $lowerId);
+        $this->client->del($permDocKey ?? $this->permDocKey($collection, $lowerId));
     }
 
-    public function upsertDocuments(
-        Document $collection,
-        string $attribute,
-        array $changes
-    ): array {
-        if (empty($changes)) {
-            return $changes;
+    private function rawRestoreDoc(string $collection, string $id, string $payload, ?string $docKey = null, ?string $idxKey = null): void
+    {
+        $lowerId = \strtolower($id);
+        $this->client->set($docKey ?? $this->docKey($collection, $lowerId), $payload);
+        $this->client->sAdd($idxKey ?? $this->idxKey($collection), $lowerId);
+    }
+
+    /**
+     * @return array<int, array<string, mixed>>
+     */
+    private function readAttributesField(RedisClient $client, string $metaKey): array
+    {
+        $raw = $client->hGet($metaKey, 'attrs');
+        if (! \is_string($raw) || $raw === '') {
+            return [];
         }
+        /** @var array<int, array<string, mixed>> $decoded */
+        $decoded = \json_decode($raw, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
 
-        $col = $this->filter($collection->getId());
+        return \array_values($decoded);
+    }
 
-        return $this->tx(function (RedisClient $redis) use ($col, $attribute, $changes): array {
-            $results = [];
+    /**
+     * @return array<int, array<string, mixed>>
+     */
+    private function readIndexesField(RedisClient $client, string $metaKey): array
+    {
+        $raw = $client->hGet($metaKey, 'indexes');
+        if (! \is_string($raw) || $raw === '') {
+            return [];
+        }
+        $decoded = \json_decode($raw, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
+        if (! \is_array($decoded)) {
+            return [];
+        }
 
-            // Phase 1: pipeline GETs of every doc so we know create vs update
-            // in a single round trip. Mirror createDocument and route every
-            // doc/idx/seq key through the document's own tenant so a batch
-            // that mixes tenants under shared tables doesn't silently
-            // misroute to the adapter-bound bucket.
-            $redis->multi(\Redis::PIPELINE);
-            foreach ($changes as $change) {
-                $document = $change->getNew();
-                $redis->get($this->docKey($col, $document->getId(), $document->getTenant()));
-            }
-            $existingPayloads = $redis->exec();
-            if (! \is_array($existingPayloads)) {
-                $existingPayloads = [];
-            }
+        /** @var array<int, array<string, mixed>> $decoded */
+        return $decoded;
+    }
 
-            // Cache the relationship-key list once per bulk call (see
-            // updateDocuments) so we surface nulls without re-reading
-            // meta.attrs per change.
-            $relationshipKeys = [];
-            if ($col !== Database::METADATA) {
-                $metaKey = $this->key($this->ns(), 'meta', $this->filter($col));
-                $attributes = $this->readAttributesField($redis, $metaKey);
-                $relationshipKeys = $this->extractRelationshipKeys($attributes);
-            }
-
-            foreach ($changes as $i => $change) {
-                $document = $change->getNew();
-                $id = $document->getId();
-                $tenant = $document->getTenant();
-                $docKey = $this->docKey($col, $id, $tenant);
-                $idxKey = $this->idxKey($col, $tenant);
-                $seqKey = $this->seqKey($col, $tenant);
-                $existingPayload = $existingPayloads[$i] ?? false;
-
-                if (\is_string($existingPayload) && $existingPayload !== '') {
-                    $existing = $this->decode($existingPayload);
-                    if (! empty($relationshipKeys)) {
-                        $existing = $this->surfaceRelationshipAttributesUsing($relationshipKeys, $existing);
-                    }
-                    $existingArray = $existing->getArrayCopy();
-                    $resolved = $this->applyOperators($document->getArrayCopy(), $existingArray);
-                    $merged = \array_merge($existingArray, $resolved);
-                    $merged['$id'] = $id;
-
-                    if ($attribute !== '') {
-                        $previous = $existing->getAttribute($attribute);
-                        $delta = $document->getAttribute($attribute);
-                        $previousNumeric = \is_numeric($previous) ? $previous + 0 : 0;
-                        $deltaNumeric = \is_numeric($delta) ? $delta + 0 : 0;
-                        $merged[$attribute] = $previousNumeric + $deltaNumeric;
-                    }
-
-                    $mergedDocument = new Document($merged);
-                    $redis->set($docKey, $this->encode($mergedDocument));
-
-                    $this->journal('updateDoc', [
-                        'collection' => $col,
-                        'id' => $id,
-                        'newId' => $id,
-                        'payload' => $existingPayload,
-                        'docKey' => $docKey,
-                    ]);
-
-                    $this->clearPermissions($col, $id);
-                    $this->writePermissions($col, $id, $mergedDocument);
-
-                    $results[] = $mergedDocument;
-                } else {
-                    // Insert path: parity with createDocument — reject writes
-                    // that would violate a UNIQUE index before the row lands
-                    // in the keyspace.
-                    $this->enforceUniqueIndexes($redis, $col, $document);
-
-                    $sequence = $document->getSequence();
-                    if (empty($sequence)) {
-                        $next = $redis->incr($seqKey);
-                        $sequence = (string) $next;
-                    } else {
-                        $sequence = (string) $sequence;
-                        $current = $redis->get($seqKey);
-                        if (! \is_string($current) || (int) $sequence > (int) $current) {
-                            $redis->set($seqKey, $sequence);
-                        }
-                    }
-                    $document->setAttribute('$sequence', $sequence);
-
-                    $resolved = $this->applyOperators($document->getArrayCopy(), []);
-                    foreach ($resolved as $attr => $value) {
-                        $document->setAttribute($attr, $value);
-                    }
-
-                    $redis->set($docKey, $this->encode($document));
-                    $redis->sAdd($idxKey, \strtolower($id));
-
-                    $this->writePermissions($col, $id, $document);
-                    $this->journal('createDoc', [
-                        'collection' => $col,
-                        'id' => $id,
-                        'docKey' => $docKey,
-                        'idxKey' => $idxKey,
-                        'permDocKey' => $this->permDocKey($col, $id),
-                    ]);
-
-                    $results[] = $document;
-                }
+    /**
+     * @param array<int, array<string, mixed>> $attrs
+     * @param array<string, mixed> $record
+     * @return array<int, array<string, mixed>>
+     */
+    private function upsertAttributeRecord(array $attrs, array $record): array
+    {
+        $targetId = $this->stringOrEmpty($record[Document::ID] ?? '');
+        $replaced = false;
+        foreach ($attrs as $i => $existing) {
+            $existingId = $this->recordIdentifier($existing);
+            if ($existingId !== $targetId) {
+                continue;
             }
+            $attrs[$i] = $record;
+            $replaced = true;
+            break;
+        }
+        if (! $replaced) {
+            $attrs[] = $record;
+        }
 
-            return $results;
-        });
+        return \array_values($attrs);
     }
 
-    public function getSequences(string $collection, array $documents): array
+    private function enforceUniqueIndexes(RedisClient $client, string $collection, Document $document, ?string $excludeId = null): void
     {
-        if (empty($documents)) {
-            return $documents;
-        }
+        $metaKey = $this->key($this->ns(), 'meta', $collection);
+        $indexes = $this->readIndexesField($client, $metaKey);
 
-        $this->client->multi(\Redis::PIPELINE);
-        try {
-            $indexes = [];
-            foreach ($documents as $index => $doc) {
-                if (! empty($doc->getSequence())) {
-                    continue;
-                }
-                $this->client->get($this->docKey($collection, $doc->getId()));
-                $indexes[] = $index;
+        $uniqueIndexes = [];
+        foreach ($indexes as $index) {
+            if (($index['type'] ?? '') !== IndexType::Unique->value) {
+                continue;
             }
-            // No work queued — discard the empty pipeline so the connection
-            // does not stay in MULTI mode after returning early.
-            if ($indexes === []) {
-                try {
-                    $this->client->discard();
-                } catch (\Throwable) {
-                    // PIPELINE-mode discard is version-dependent across phpredis.
+            $attributes = $index['attributes'] ?? [];
+            if (empty($attributes) || ! \is_array($attributes)) {
+                continue;
+            }
+            $names = [];
+            foreach ($attributes as $attribute) {
+                if (\is_string($attribute) && $attribute !== '') {
+                    $names[] = $attribute;
                 }
-                return $documents;
             }
-            $payloads = $this->client->exec();
-        } catch (\Throwable $e) {
-            try {
-                $this->client->discard();
-            } catch (\Throwable) {
-                // PIPELINE-mode discard is version-dependent across phpredis.
+            if ($names === []) {
+                continue;
             }
-            throw new TransactionException('Failed to load sequences: ' . $e->getMessage(), 0, $e);
+            $uniqueIndexes[] = $names;
         }
-        if (! \is_array($payloads)) {
-            return $documents;
+
+        if ($uniqueIndexes === []) {
+            return;
         }
 
-        foreach ($indexes as $position => $index) {
-            $payload = $payloads[$position] ?? false;
-            if (! \is_string($payload) || $payload === '') {
+        $newSignatures = [];
+        $sharedTables = $this->getSharedTables();
+        $tenant = $sharedTables ? ($document->getAttribute(Document::TENANT) ?? $this->getTenant()) : null;
+        foreach ($uniqueIndexes as $i => $attributes) {
+            $signature = [];
+            $hasNull = false;
+            foreach ($attributes as $attribute) {
+                $value = $this->resolveDocumentAttribute($document, $attribute);
+                if ($value === null) {
+                    $hasNull = true;
+                    break;
+                }
+                $signature[] = $this->normalizeIndexValue($value);
+            }
+            if ($hasNull) {
                 continue;
             }
-            $existing = $this->decode($payload);
-            $sequence = $existing->getSequence();
-            if (! empty($sequence)) {
-                $documents[$index]->setAttribute('$sequence', (string) $sequence);
+            if ($sharedTables) {
+                \array_unshift($signature, $tenant);
             }
+            $newSignatures[$i] = \serialize($signature);
         }
 
-        return $documents;
-    }
-
-    public function deleteDocument(string $collection, string $id): bool
-    {
-        $collection = $this->filter($collection);
-        $docKey = $this->docKey($collection, $id);
-        $idxKey = $this->idxKey($collection);
-
-        return $this->tx(function (RedisClient $redis) use ($collection, $id, $docKey, $idxKey): bool {
-            $payload = $redis->get($docKey);
-            if (! \is_string($payload) || $payload === '') {
-                return false;
-            }
-
-            $this->journal('deleteDoc', [
-                'collection' => $collection,
-                'id' => $id,
-                'payload' => $payload,
-                'docKey' => $docKey,
-                'idxKey' => $idxKey,
-            ]);
-
-            $this->clearPermissions($collection, $id);
-            $redis->del($docKey);
-            $redis->sRem($idxKey, \strtolower($id));
-
-            return true;
-        });
-    }
-
-    public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
-    {
-        if (empty($sequences) && empty($permissionIds)) {
-            return 0;
+        if ($newSignatures === []) {
+            return;
         }
 
-        $collection = $this->filter($collection);
         $idxKey = $this->idxKey($collection);
+        /** @var array<int, string>|false $docIds */
+        $docIds = $client->sMembers($idxKey);
+        if (! \is_array($docIds) || empty($docIds)) {
+            return;
+        }
 
-        return $this->tx(function (RedisClient $redis) use ($collection, $sequences, $permissionIds, $idxKey): int {
-            $sequenceSet = [];
-            foreach ($sequences as $sequence) {
-                $sequenceSet[(string) $sequence] = true;
-            }
-
-            $allIds = $redis->sMembers($idxKey);
-            if (! \is_array($allIds)) {
-                $allIds = [];
+        $excludeKey = $excludeId !== null ? \strtolower($excludeId) : null;
+        $docKeys = [];
+        foreach ($docIds as $docId) {
+            if ($excludeKey !== null && \strtolower((string) $docId) === $excludeKey) {
+                continue;
             }
+            $docKeys[(string) $docId] = $this->docKey($collection, (string) $docId);
+        }
+        if ($docKeys === []) {
+            return;
+        }
 
-            $docKeys = [];
-            $redis->multi(\Redis::PIPELINE);
-            foreach ($allIds as $id) {
-                $docKey = $this->docKey($collection, (string) $id);
-                $docKeys[(string) $id] = $docKey;
-                $redis->get($docKey);
-            }
-            $payloads = $redis->exec();
-            if (! \is_array($payloads)) {
-                $payloads = [];
+        /** @var array<int, mixed> $payloads */
+        $payloads = $client->mGet(\array_values($docKeys));
+        $position = 0;
+        foreach ($docKeys as $docId => $_) {
+            $payload = $payloads[$position++] ?? null;
+            if (! \is_string($payload) || $payload === '') {
+                continue;
             }
-
-            $deleted = [];
-            foreach ($allIds as $position => $id) {
-                $payload = $payloads[$position] ?? false;
-                if (! \is_string($payload) || $payload === '') {
+            $existing = $this->decode($payload);
+            if ($sharedTables) {
+                $rowTenant = $existing->getAttribute(Document::TENANT);
+                if ($rowTenant !== $tenant) {
                     continue;
                 }
-                $document = $this->decode($payload);
-                $matchesSequence = isset($sequenceSet[(string) $document->getSequence()]);
-                if ($matchesSequence) {
-                    $deleted[$document->getId()] = ['payload' => $payload, 'docKey' => $docKeys[(string) $id]];
-                }
             }
-
-            foreach ($deleted as $documentId => $deleteEntry) {
-                $deletedDocKey = $deleteEntry['docKey'];
-                $this->journal('deleteDoc', [
-                    'collection' => $collection,
-                    'id' => (string) $documentId,
-                    'payload' => $deleteEntry['payload'],
-                    'docKey' => $deletedDocKey,
-                    'idxKey' => $idxKey,
-                ]);
-                $this->clearPermissions($collection, (string) $documentId);
-                $redis->del($deletedDocKey);
-                $redis->sRem($idxKey, \strtolower((string) $documentId));
-            }
-
-            // Permission-only cleanup for ids the caller listed but that did
-            // not match by sequence — mirrors Memory adapter semantics.
-            foreach ($permissionIds as $permissionId) {
-                $documentId = (string) $permissionId;
-                if (isset($deleted[$documentId])) {
+            foreach ($newSignatures as $i => $newHash) {
+                $attributes = $uniqueIndexes[$i];
+                $signature = [];
+                $hasNull = false;
+                foreach ($attributes as $attribute) {
+                    $value = $this->resolveDocumentAttribute($existing, $attribute);
+                    if ($value === null) {
+                        $hasNull = true;
+                        break;
+                    }
+                    $signature[] = $this->normalizeIndexValue($value);
+                }
+                if ($hasNull) {
                     continue;
                 }
-                $this->clearPermissions($collection, $documentId);
+                if ($sharedTables) {
+                    \array_unshift($signature, $tenant);
+                }
+                if (\serialize($signature) === $newHash) {
+                    throw new DuplicateException('Document with the requested unique attributes already exists');
+                }
             }
-
-            return \count($deleted);
-        });
+        }
     }
 
-    public function increaseDocumentAttribute(
-        string $collection,
-        string $id,
-        string $attribute,
-        int|float $value,
-        string $updatedAt,
-        int|float|null $min = null,
-        int|float|null $max = null
-    ): bool {
+    private function purgeCollectionKeys(RedisClient $client, string $namespace, string $database, string $collection): void
+    {
         $collection = $this->filter($collection);
-        $docKey = $this->docKey($collection, $id);
-
-        return $this->tx(function (RedisClient $redis) use ($collection, $id, $attribute, $value, $updatedAt, $min, $max, $docKey): bool {
-            $payload = $redis->get($docKey);
-            if (! \is_string($payload) || $payload === '') {
-                throw new NotFoundException('Document not found');
-            }
-
-            $document = $this->decode($payload);
-            $current = $document->getAttribute($attribute);
-            $current = \is_numeric($current) ? $current + 0 : 0;
+        $prefix = $this->nsFor($namespace, $database);
+        $metaKey = $this->key($prefix, 'meta', $collection);
+        $idxKey = $this->key($prefix, 'idx', $collection);
+        $seqKey = $this->key($prefix, 'seq', $collection);
 
-            // Mirrors MariaDB's bound semantics — silent no-op when bounds
-            // exclude the row. Caller has pre-adjusted bounds by $value.
-            if (! \is_null($min) && $current < $min) {
-                return true;
+        /** @var array<int, string>|false $docIds */
+        $docIds = $client->sMembers($idxKey);
+        if (\is_array($docIds) && $docIds !== []) {
+            $keys = [];
+            foreach ($docIds as $docId) {
+                $keys[] = $this->key($prefix, 'doc', $collection, $docId);
+                $keys[] = $this->key($prefix, 'perm', 'doc', $collection, $docId);
+                if (\count($keys) >= self::SCAN_BATCH_SIZE) {
+                    $client->del(...$keys);
+                    $keys = [];
+                }
             }
-            if (! \is_null($max) && $current > $max) {
-                return true;
+            if ($keys !== []) {
+                $client->del(...$keys);
             }
+        }
 
-            $document->setAttribute($attribute, $current + $value);
-            $document->setAttribute('$updatedAt', $updatedAt);
-
-            $redis->set($docKey, $this->encode($document));
+        $this->deleteByPattern($client, $prefix.self::SEP.'doc'.self::SEP.'t'.self::SEP.'*'.self::SEP.$collection.self::SEP.'*');
+        $this->deleteByPattern($client, $prefix.self::SEP.'idx'.self::SEP.'t'.self::SEP.'*'.self::SEP.$collection);
+        $this->deleteByPattern($client, $prefix.self::SEP.'seq'.self::SEP.'t'.self::SEP.'*'.self::SEP.$collection);
 
-            $this->journal('updateDoc', [
-                'collection' => $collection,
-                'id' => $id,
-                'newId' => $id,
-                'payload' => $payload,
-                'docKey' => $docKey,
-            ]);
+        $this->deleteByPattern($client, $this->key($prefix, 'perm', $collection).self::SEP.'*');
+        $this->deleteByPattern($client, $prefix.self::SEP.'perm'.self::SEP.'t'.self::SEP.'*'.self::SEP.$collection.self::SEP.'*');
+        $this->deleteByPattern($client, $prefix.self::SEP.'perm'.self::SEP.'t'.self::SEP.'*'.self::SEP.'doc'.self::SEP.$collection.self::SEP.'*');
+        $this->deleteByPattern($client, $this->key($prefix, 'tenants', $collection).self::SEP.'*');
 
-            return true;
-        });
+        $client->del($metaKey, $idxKey, $seqKey);
     }
 
-    // === @architect:T30 end ===
-
-
-
-
-
-    // === @architect:T40 owns: indexes + queries + counts ===
-
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
+    private function deleteByPattern(RedisClient $client, string $pattern): void
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
-        $metaKey = $this->key($this->ns(), 'meta', $collection);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        return $this->tx(function (RedisClient $client) use ($metaKey, $collection, $id, $type, $attributes, $lengths, $orders): bool {
-            $indexes = $this->readIndexesField($client, $metaKey);
-
-            foreach ($indexes as $existing) {
-                if (($existing['$id'] ?? $existing['key'] ?? null) === $id) {
-                    throw new DuplicateException('Index already exists');
-                }
-            }
-
-            // Unique-index pre-flight: scan existing documents for collisions so
-            // index creation fails up-front rather than silently allowing
-            // duplicate values to coexist under a "unique" constraint.
-            if ($type === Database::INDEX_UNIQUE && ! empty($attributes)) {
-                $idxKey = $this->idxKey($collection);
-                /** @var array<int, string> $docIds */
-                $docIds = $client->sMembers($idxKey);
-                if (! empty($docIds)) {
-                    $sharedTables = $this->getSharedTables();
-                    $currentTenant = $sharedTables ? $this->getTenant() : null;
-                    // Single mGet round trip instead of N sequential GETs so
-                    // unique-index creation on a populated collection scales
-                    // with payload size rather than RTT count.
-                    $docKeys = [];
-                    foreach ($docIds as $docId) {
-                        $docKeys[] = $this->docKey($collection, (string) $docId);
-                    }
-                    /** @var array<int, mixed> $payloads */
-                    $payloads = $client->mGet($docKeys);
-                    $seen = [];
-                    foreach ($payloads as $payload) {
-                        if (! \is_string($payload)) {
-                            continue;
-                        }
-                        $document = $this->decode($payload);
-                        // Under shared tables the inverted-index set fans
-                        // across every tenant; only probe rows that belong
-                        // to the active tenant so cross-tenant rows don't
-                        // produce spurious collisions.
-                        if ($sharedTables) {
-                            $rowTenant = $document->getAttribute('$tenant');
-                            if ($rowTenant !== $currentTenant) {
-                                continue;
-                            }
-                        }
-                        $signature = [];
-                        $hasNull = false;
-                        foreach ($attributes as $attribute) {
-                            $value = $this->resolveDocumentAttribute($document, (string) $attribute);
-                            if ($value === null) {
-                                $hasNull = true;
-                                break;
-                            }
-                            $signature[] = $this->normalizeIndexValue($value);
-                        }
-                        if ($hasNull) {
-                            continue;
-                        }
-                        if ($sharedTables) {
-                            \array_unshift($signature, $currentTenant);
-                        }
-                        $hash = \serialize($signature);
-                        if (isset($seen[$hash])) {
-                            throw new DuplicateException('Cannot create unique index: existing rows already contain duplicate values');
-                        }
-                        $seen[$hash] = true;
-                    }
-                }
-            }
-
-            $indexes[] = [
-                '$id' => $id,
-                'key' => $id,
-                'type' => $type,
-                'attributes' => \array_values($attributes),
-                'lengths' => \array_values($lengths),
-                'orders' => \array_values($orders),
-            ];
-
-            $client->hSet(
-                $metaKey,
-                'indexes',
-                \json_encode($indexes, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
-
-            return true;
-        });
+        $cursor = null;
+        do {
+            /** @var array<int, string>|false $batch */
+            $batch = $client->scan($cursor, $pattern, self::SCAN_BATCH_SIZE);
+            if (\is_array($batch) && $batch !== []) {
+                $client->del(...$batch);
+            }
+        } while ($cursor !== 0 && $cursor !== null);
     }
 
-    public function deleteIndex(string $collection, string $id): bool
+    private function computeCollectionSize(string $collection): int
     {
         $collection = $this->filter($collection);
-        $id = $this->filter($id);
         $metaKey = $this->key($this->ns(), 'meta', $collection);
 
         if ((bool) $this->client->exists($metaKey) === false) {
-            return true;
+            return 0;
         }
 
-        return $this->tx(function (RedisClient $client) use ($metaKey, $id): bool {
-            $indexes = $this->readIndexesField($client, $metaKey);
-            $filtered = [];
-            foreach ($indexes as $index) {
-                if (($index['$id'] ?? $index['key'] ?? null) === $id) {
-                    continue;
+        $total = $this->measureKey($metaKey);
+
+        $idxKey = $this->idxKey($collection);
+        $total += $this->measureKey($idxKey);
+
+        /** @var array<int, string>|false $docIds */
+        $docIds = $this->client->sMembers($idxKey);
+        if (\is_array($docIds)) {
+            foreach ($docIds as $docId) {
+                $total += $this->measureKey($this->docKey($collection, (string) $docId));
+                $total += $this->measureKey($this->permDocKey($collection, (string) $docId));
+            }
+        }
+
+        $bucket = $this->tenantBucket();
+        if ($bucket !== null) {
+            $permPrefix = $this->ns().self::SEP.'perm'.self::SEP.'t'.self::SEP.$bucket.self::SEP.$collection.self::SEP.'*';
+        } else {
+            $permPrefix = $this->key($this->ns(), 'perm', $collection).self::SEP.'*';
+        }
+        $cursor = null;
+        do {
+            /** @var array<int, string>|false $batch */
+            $batch = $this->client->scan($cursor, $permPrefix, self::SCAN_BATCH_SIZE);
+            if (\is_array($batch)) {
+                foreach ($batch as $key) {
+                    $total += $this->measureKey($key);
                 }
-                $filtered[] = $index;
             }
+        } while ($cursor !== 0 && $cursor !== null);
 
-            $client->hSet(
-                $metaKey,
-                'indexes',
-                \json_encode(\array_values($filtered), JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
+        return $total;
+    }
 
-            return true;
-        });
+    private function measureKey(string $key): int
+    {
+        try {
+            /** @var int|false|null $usage */
+            $usage = $this->client->rawCommand('MEMORY', 'USAGE', $key);
+            if (\is_int($usage)) {
+                return $usage;
+            }
+        } catch (\Throwable) {
+            // Fall through to the structural fallback below.
+        }
+
+        $type = $this->client->type($key);
+        switch ($type) {
+            case RedisClient::REDIS_STRING:
+                $value = $this->client->get($key);
+
+                return \is_string($value) ? \strlen($value) + \strlen($key) : 0;
+            case RedisClient::REDIS_HASH:
+                $entries = $this->client->hGetAll($key);
+                $bytes = \strlen($key);
+                if (\is_array($entries)) {
+                    foreach ($entries as $field => $value) {
+                        $bytes += \strlen((string) $field) + \strlen((string) $value);
+                    }
+                }
+
+                return $bytes;
+            case RedisClient::REDIS_SET:
+                $members = $this->client->sMembers($key);
+                $bytes = \strlen($key);
+                if (\is_array($members)) {
+                    foreach ($members as $member) {
+                        $bytes += \strlen((string) $member);
+                    }
+                }
+
+                return $bytes;
+            default:
+                return 0;
+        }
     }
 
-    public function renameIndex(string $collection, string $old, string $new): bool
+    private function registerRelationshipField(string $collection, string $field): void
     {
         $collection = $this->filter($collection);
-        $old = $this->filter($old);
-        $new = $this->filter($new);
+        $field = $this->filter($field);
         $metaKey = $this->key($this->ns(), 'meta', $collection);
 
         if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
+            return;
         }
 
-        return $this->tx(function (RedisClient $client) use ($metaKey, $old, $new): bool {
-            $indexes = $this->readIndexesField($client, $metaKey);
-            $changed = false;
-            foreach ($indexes as $i => $index) {
-                if (($index['$id'] ?? $index['key'] ?? null) === $old) {
-                    $indexes[$i]['$id'] = $new;
-                    $indexes[$i]['key'] = $new;
-                    $changed = true;
-                    break;
-                }
-            }
-
-            if (! $changed) {
-                return true;
-            }
-
-            $client->hSet(
-                $metaKey,
-                'indexes',
-                \json_encode(\array_values($indexes), JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE),
-            );
+        $record = [
+            Document::ID => $field,
+            'key' => $field,
+            'type' => ColumnType::Relationship->value,
+            'size' => 0,
+            'signed' => true,
+            'array' => false,
+            'required' => false,
+        ];
 
-            return true;
+        $this->tx(function (RedisClient $client) use ($metaKey, $record): void {
+            $attrs = $this->readAttributesField($client, $metaKey);
+            $attrs = $this->upsertAttributeRecord($attrs, $record);
+            $client->hSet($metaKey, 'attrs', \json_encode($attrs, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE));
         });
     }
 
-    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array
+    private function renameDocumentField(string $collection, string $oldKey, string $newKey): void
     {
-        $collectionId = $this->filter($collection->getId());
-        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
+        $collection = $this->filter($collection);
+        $oldKey = $this->filter($oldKey);
+        $newKey = $this->filter($newKey);
 
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
+        if ($oldKey === $newKey) {
+            return;
         }
 
-        return $this->tx(function (RedisClient $client) use ($collectionId, $queries, $limit, $offset, $orderAttributes, $orderTypes, $cursor, $cursorDirection, $forPermission): array {
-            $documents = $this->loadCollectionDocuments($client, $collectionId, $forPermission);
-            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
-            $documents = $this->orderDocuments($documents, $orderAttributes, $orderTypes, $cursorDirection);
-            $documents = $this->cursorDocuments($documents, $orderAttributes, $orderTypes, $cursor, $cursorDirection);
+        $idxKey = $this->idxKey($collection);
 
-            if (! \is_null($offset)) {
-                $documents = \array_slice($documents, $offset);
-            }
-            if (! \is_null($limit)) {
-                $documents = \array_slice($documents, 0, $limit);
+        $this->tx(function (RedisClient $client) use ($collection, $oldKey, $newKey, $idxKey): void {
+            /** @var array<int, string>|false $docIds */
+            $docIds = $client->sMembers($idxKey);
+            if (! \is_array($docIds) || $docIds === []) {
+                return;
             }
 
-            $selections = $this->extractSelectionsFromQueries($queries);
-            if (! empty($selections)) {
-                $projected = [];
-                foreach ($documents as $document) {
-                    $projected[] = $this->projectDocument($document, $selections);
+            foreach ($docIds as $docId) {
+                $docKey = $this->docKey($collection, $docId);
+                $payload = $client->get($docKey);
+                if (! \is_string($payload) || $payload === '') {
+                    continue;
                 }
-                $documents = $projected;
-            }
 
-            if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $documents = \array_reverse($documents);
-            }
+                /** @var array<string, mixed> $decoded */
+                $decoded = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
+                if (! \array_key_exists($oldKey, $decoded)) {
+                    continue;
+                }
 
-            return $documents;
+                $decoded[$newKey] = $decoded[$oldKey];
+                unset($decoded[$oldKey]);
+
+                $client->set(
+                    $docKey,
+                    \json_encode($decoded, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION),
+                );
+            }
         });
     }
 
-    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): float|int
+    private function dropDocumentField(string $collection, string $field): void
     {
-        $collectionId = $this->filter($collection->getId());
-        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        return $this->tx(function (RedisClient $client) use ($collectionId, $attribute, $queries, $max): float|int {
-            $documents = $this->loadCollectionDocuments($client, $collectionId, Database::PERMISSION_READ);
-            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
+        $collection = $this->filter($collection);
+        $field = $this->filter($field);
+        $idxKey = $this->idxKey($collection);
 
-            if (! \is_null($max)) {
-                $documents = \array_slice($documents, 0, $max);
+        $this->tx(function (RedisClient $client) use ($collection, $field, $idxKey): void {
+            /** @var array<int, string>|false $docIds */
+            $docIds = $client->sMembers($idxKey);
+            if (! \is_array($docIds) || $docIds === []) {
+                return;
             }
 
-            $sum = 0;
-            $isFloat = false;
-            foreach ($documents as $document) {
-                $value = $this->resolveDocumentAttribute($document, $attribute);
-                if ($value === null) {
+            foreach ($docIds as $docId) {
+                $docKey = $this->docKey($collection, $docId);
+                $payload = $client->get($docKey);
+                if (! \is_string($payload) || $payload === '') {
                     continue;
                 }
-                if (\is_float($value)) {
-                    $isFloat = true;
-                }
-                if (\is_numeric($value)) {
-                    $sum += $value;
+
+                /** @var array<string, mixed> $decoded */
+                $decoded = \json_decode($payload, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
+                if (! \array_key_exists($field, $decoded)) {
+                    continue;
                 }
-            }
 
-            return $isFloat ? (float) $sum : (int) $sum;
+                unset($decoded[$field]);
+
+                $client->set(
+                    $docKey,
+                    \json_encode($decoded, JSON_THROW_ON_ERROR | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION),
+                );
+            }
         });
     }
 
-    public function count(Document $collection, array $queries = [], ?int $max = null): int
+    private function resolveJunctionCollection(string $collection, string $relatedCollection, RelationSide $side): ?string
     {
-        $collectionId = $this->filter($collection->getId());
-        $metaKey = $this->key($this->ns(), 'meta', $collectionId);
-
-        if ((bool) $this->client->exists($metaKey) === false) {
-            throw new NotFoundException('Collection not found');
+        $collectionDoc = $this->loadMetadataDocument($collection);
+        $relatedDoc = $this->loadMetadataDocument($relatedCollection);
+        if ($collectionDoc === null || $relatedDoc === null) {
+            return null;
         }
 
-        // Fast path: no query filters, authorization disabled, and shared
-        // tables off means the `idx:{collection}` SET cardinality matches the
-        // visible doc count directly. Under shared tables the SET is shared
-        // across tenants — `sCard` would return the union count, leaking
-        // cross-tenant rows — so we fall through to the slow path which
-        // hydrates and tenant-filters via `loadCollectionDocuments`.
-        // Authorization-on also requires hydration so the permission filter
-        // actually runs.
-        // TODO: this path still scans the full collection when queries are
-        // present — acceptable parity with Memory, but a known scaling limit
-        // and unsuitable for large production collections.
-        if (
-            empty($queries)
-            && $this->authorization->getStatus() === false
-            && $this->getSharedTables() === false
-        ) {
-            $idxKey = $this->idxKey($collectionId);
-            $cardinality = $this->client->sCard($idxKey);
-            if (\is_int($cardinality)) {
-                return $max === null ? $cardinality : \min($max, $cardinality);
-            }
+        $collectionSequence = $collectionDoc->getSequence();
+        $relatedSequence = $relatedDoc->getSequence();
+        if ($collectionSequence === null || $relatedSequence === null || $collectionSequence === '' || $relatedSequence === '') {
+            return null;
         }
 
-        return $this->tx(function (RedisClient $client) use ($collectionId, $queries, $max): int {
-            $documents = $this->loadCollectionDocuments($client, $collectionId, Database::PERMISSION_READ);
-            $documents = $this->filterDocumentsByQueries($collectionId, $documents, $queries);
+        return $side === RelationSide::Parent
+            ? '_'.$collectionSequence.'_'.$relatedSequence
+            : '_'.$relatedSequence.'_'.$collectionSequence;
+    }
 
-            if (! \is_null($max)) {
-                $documents = \array_slice($documents, 0, $max);
-            }
+    private function loadMetadataDocument(string $collection): ?Document
+    {
+        $id = $this->filter($collection);
+        $payload = $this->client->get($this->docKey(Database::METADATA, $id));
+        if ((! \is_string($payload) || $payload === '') && $this->getSharedTables()) {
+            $payload = $this->client->get($this->docKey(Database::METADATA, $id, '_'));
+        }
+        if (! \is_string($payload) || $payload === '') {
+            return null;
+        }
 
-            return \count($documents);
-        });
+        return $this->decode($payload);
     }
 
-    public function getSchemaIndexes(string $collection): array
+    private function surfaceRelationshipAttributes(string $collection, Document $document): Document
     {
-        // Mirror Memory: Redis maintains no on-disk schema, so the adapter
-        // exposes no schema-level indexes. Index metadata lives on the
-        // collection Document and is read by Database via getCollection().
-        return [];
+        if ($collection === Database::METADATA) {
+            return $document;
+        }
+
+        $metaKey = $this->key($this->ns(), 'meta', $this->filter($collection));
+        $attributes = $this->readAttributesField($this->client, $metaKey);
+        $relationshipKeys = $this->extractRelationshipKeys($attributes);
+        if ($relationshipKeys === []) {
+            return $document;
+        }
+
+        return $this->surfaceRelationshipAttributesUsing($relationshipKeys, $document);
     }
 
-    public function getCountOfIndexes(Document $collection): int
+    /**
+     * @param array<int, string> $relationshipKeys
+     */
+    private function surfaceRelationshipAttributesUsing(array $relationshipKeys, Document $document): Document
     {
-        return \count($collection->getAttribute('indexes', [])) + \count(Database::INTERNAL_INDEXES);
+        if ($relationshipKeys === []) {
+            return $document;
+        }
+
+        $payload = $document->getArrayCopy();
+        foreach ($relationshipKeys as $key) {
+            if (! \array_key_exists($key, $payload)) {
+                $document->setAttribute($key, null);
+            }
+        }
+
+        return $document;
     }
 
     /**
-     * Read and JSON-decode the indexes field on a collection meta hash.
-     *
-     * @return array<int, array<string, mixed>>
+     * @param array<int, array<string, mixed>> $attributes
+     * @return array<int, string>
      */
-    private function readIndexesField(RedisClient $client, string $metaKey): array
+    private function extractRelationshipKeys(array $attributes): array
     {
-        $raw = $client->hGet($metaKey, 'indexes');
-        if (! \is_string($raw) || $raw === '') {
-            return [];
-        }
-        $decoded = \json_decode($raw, true, self::JSON_DECODE_DEPTH, JSON_THROW_ON_ERROR);
-        if (! \is_array($decoded)) {
-            return [];
+        $keys = [];
+        foreach ($attributes as $attribute) {
+            if (($attribute['type'] ?? null) !== ColumnType::Relationship->value) {
+                continue;
+            }
+            $key = $this->recordIdentifier($attribute);
+            if ($key === '') {
+                continue;
+            }
+            $keys[] = $key;
         }
 
-        /** @var array<int, array<string, mixed>> $decoded */
-        return $decoded;
+        return $keys;
     }
 
     /**
-     * Hydrate every document in the collection's id-set, applying tenant and
-     * permission filters. Returns Documents in insertion-set order.
-     *
      * @return array<int, Document>
      */
-    private function loadCollectionDocuments(RedisClient $client, string $collection, string $forPermission): array
+    private function loadCollectionDocuments(RedisClient $client, string $collection, PermissionType $forPermission): array
     {
         $idxKey = $this->idxKey($collection);
-        /** @var array<int, string> $ids */
+        /** @var array<int, string>|false $ids */
         $ids = $client->sMembers($idxKey);
-        if (empty($ids)) {
+        if (! \is_array($ids) || empty($ids)) {
             return [];
         }
 
-        // Permission filter through the T50-owned hook before fetching to
-        // avoid round-tripping payloads we will discard anyway.
         if ($this->authorization->getStatus()) {
             $ids = $this->applyPermissionFilter($collection, $ids, $forPermission);
             if (empty($ids)) {
@@ -3008,9 +2531,6 @@ private function loadCollectionDocuments(RedisClient $client, string $collection
         $tenant = $sharedTables ? $this->getTenant() : null;
         $allowNullTenant = $sharedTables && $collection === Database::METADATA;
 
-        // Read meta.attrs once and cache the relationship-key list across the
-        // decode loop — `surfaceRelationshipAttributes` would re-read meta on
-        // every document otherwise.
         $relationshipKeys = [];
         if ($collection !== Database::METADATA) {
             $metaKey = $this->key($this->ns(), 'meta', $this->filter($collection));
@@ -3026,7 +2546,7 @@ private function loadCollectionDocuments(RedisClient $client, string $collection
             $document = $this->decode($payload);
 
             if ($sharedTables) {
-                $rowTenant = $document->getAttribute('$tenant');
+                $rowTenant = $document->getAttribute(Document::TENANT);
                 $crossTenant = $rowTenant !== $tenant
                     && ! ($allowNullTenant && $rowTenant === null);
                 if ($crossTenant) {
@@ -3045,10 +2565,8 @@ private function loadCollectionDocuments(RedisClient $client, string $collection
     }
 
     /**
-     * Apply non-pagination query filters to the supplied documents.
-     *
-     * @param  array<int, Document>  $documents
-     * @param  array<int, Query>  $queries
+     * @param array<int, Document> $documents
+     * @param array<Query> $queries
      * @return array<int, Document>
      */
     private function filterDocumentsByQueries(string $collection, array $documents, array $queries): array
@@ -3061,14 +2579,14 @@ private function filterDocumentsByQueries(string $collection, array $documents,
         foreach ($queries as $query) {
             $method = $query->getMethod();
             if (\in_array($method, [
-                Query::TYPE_SELECT,
-                Query::TYPE_ORDER_ASC,
-                Query::TYPE_ORDER_DESC,
-                Query::TYPE_ORDER_RANDOM,
-                Query::TYPE_LIMIT,
-                Query::TYPE_OFFSET,
-                Query::TYPE_CURSOR_AFTER,
-                Query::TYPE_CURSOR_BEFORE,
+                Method::Select,
+                Method::OrderAsc,
+                Method::OrderDesc,
+                Method::OrderRandom,
+                Method::Limit,
+                Method::Offset,
+                Method::CursorAfter,
+                Method::CursorBefore,
             ], true)) {
                 continue;
             }
@@ -3096,15 +2614,11 @@ private function filterDocumentsByQueries(string $collection, array $documents,
         return $output;
     }
 
-    /**
-     * Resolve a single Query against a Document, mirroring Memory's matches()
-     * but operating on the Document's natural `$id`/`$tenant`/etc. layout.
-     */
     private function matchesDocument(Document $document, Query $query): bool
     {
         $method = $query->getMethod();
 
-        if ($method === Query::TYPE_AND) {
+        if ($method === Method::And) {
             foreach ($query->getValues() as $sub) {
                 if (! ($sub instanceof Query) || ! $this->matchesDocument($document, $sub)) {
                     return false;
@@ -3114,7 +2628,7 @@ private function matchesDocument(Document $document, Query $query): bool
             return true;
         }
 
-        if ($method === Query::TYPE_OR) {
+        if ($method === Method::Or) {
             foreach ($query->getValues() as $sub) {
                 if ($sub instanceof Query && $this->matchesDocument($document, $sub)) {
                     return true;
@@ -3133,8 +2647,14 @@ private function matchesDocument(Document $document, Query $query): bool
         }
 
         switch ($method) {
-            case Query::TYPE_EQUAL:
+            case Method::Equal:
+                if ($value === null) {
+                    return false;
+                }
                 foreach ($values as $candidate) {
+                    if ($candidate === null) {
+                        continue;
+                    }
                     if ($this->valuesEqual($value, $candidate)) {
                         return true;
                     }
@@ -3142,11 +2662,14 @@ private function matchesDocument(Document $document, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_EQUAL:
+            case Method::NotEqual:
                 if ($value === null) {
                     return false;
                 }
                 foreach ($values as $candidate) {
+                    if ($candidate === null) {
+                        return false;
+                    }
                     if ($this->valuesEqual($value, $candidate)) {
                         return false;
                     }
@@ -3154,56 +2677,56 @@ private function matchesDocument(Document $document, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_LESSER:
+            case Method::LessThan:
                 return $value !== null && $value < $values[0];
 
-            case Query::TYPE_LESSER_EQUAL:
+            case Method::LessThanEqual:
                 return $value !== null && $value <= $values[0];
 
-            case Query::TYPE_GREATER:
+            case Method::GreaterThan:
                 return $value !== null && $value > $values[0];
 
-            case Query::TYPE_GREATER_EQUAL:
+            case Method::GreaterThanEqual:
                 return $value !== null && $value >= $values[0];
 
-            case Query::TYPE_IS_NULL:
+            case Method::IsNull:
                 return $value === null;
 
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNotNull:
                 return $value !== null;
 
-            case Query::TYPE_BETWEEN:
+            case Method::Between:
                 return $value !== null && $value >= $values[0] && $value <= $values[1];
 
-            case Query::TYPE_NOT_BETWEEN:
+            case Method::NotBetween:
                 if ($value === null) {
                     return false;
                 }
 
                 return $value < $values[0] || $value > $values[1];
 
-            case Query::TYPE_STARTS_WITH:
-                return \is_string($value) && \is_string($values[0] ?? null) && \str_starts_with($value, (string) $values[0]);
+            case Method::StartsWith:
+                return \is_string($value) && isset($values[0]) && \is_string($values[0]) && \str_starts_with($value, $values[0]);
 
-            case Query::TYPE_NOT_STARTS_WITH:
+            case Method::NotStartsWith:
                 if ($value === null) {
                     return false;
                 }
 
-                return ! \is_string($value) || ! \is_string($values[0] ?? null) || ! \str_starts_with($value, (string) $values[0]);
+                return ! \is_string($value) || ! isset($values[0]) || ! \is_string($values[0]) || ! \str_starts_with($value, $values[0]);
 
-            case Query::TYPE_ENDS_WITH:
-                return \is_string($value) && \is_string($values[0] ?? null) && \str_ends_with($value, (string) $values[0]);
+            case Method::EndsWith:
+                return \is_string($value) && isset($values[0]) && \is_string($values[0]) && \str_ends_with($value, $values[0]);
 
-            case Query::TYPE_NOT_ENDS_WITH:
+            case Method::NotEndsWith:
                 if ($value === null) {
                     return false;
                 }
 
-                return ! \is_string($value) || ! \is_string($values[0] ?? null) || ! \str_ends_with($value, (string) $values[0]);
+                return ! \is_string($value) || ! isset($values[0]) || ! \is_string($values[0]) || ! \str_ends_with($value, $values[0]);
 
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
+            case Method::Contains:
+            case Method::ContainsAny:
                 $haystack = $this->coerceArrayValue($value);
                 if ($haystack === null && \is_string($value)) {
                     foreach ($values as $needle) {
@@ -3227,14 +2750,14 @@ private function matchesDocument(Document $document, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_CONTAINS:
+            case Method::NotContains:
                 if ($value === null) {
                     return false;
                 }
 
-                return ! $this->matchesDocument($document, new Query(Query::TYPE_CONTAINS, $attribute, $values));
+                return ! $this->matchesDocument($document, new Query(Method::Contains, $attribute, $values));
 
-            case Query::TYPE_CONTAINS_ALL:
+            case Method::ContainsAll:
                 $haystack = $this->coerceArrayValue($value);
                 if (! \is_array($haystack)) {
                     return false;
@@ -3254,48 +2777,44 @@ private function matchesDocument(Document $document, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_SEARCH:
+            case Method::Search:
                 if (! \is_string($value)) {
                     return false;
                 }
-                $needle = (string) ($values[0] ?? '');
+                $needle = $this->stringOrEmpty($values[0] ?? '');
                 if ($needle === '') {
                     return false;
                 }
 
                 return $this->matchesFulltextRedis($value, $needle);
 
-            case Query::TYPE_NOT_SEARCH:
+            case Method::NotSearch:
                 if ($value === null) {
                     return false;
                 }
                 if (! \is_string($value)) {
                     return true;
                 }
-                $needle = (string) ($values[0] ?? '');
+                $needle = $this->stringOrEmpty($values[0] ?? '');
                 if ($needle === '') {
                     return true;
                 }
 
                 return ! $this->matchesFulltextRedis($value, $needle);
 
-            case Query::TYPE_REGEX:
+            case Method::Regex:
                 if (! \is_string($value)) {
                     return false;
                 }
-                $pattern = (string) ($values[0] ?? '');
-                $delimited = '#' . \str_replace('#', '\\#', $pattern) . '#u';
+                $pattern = $this->stringOrEmpty($values[0] ?? '');
+                $delimited = '#'.\str_replace('#', '\\#', $pattern).'#u';
 
                 return @\preg_match($delimited, $value) === 1;
         }
 
-        throw new QueryException('Query method not supported by Redis adapter: ' . $method);
+        throw new QueryException('Query method not supported by Redis adapter: '.$method->value);
     }
 
-    /**
-     * Object-attribute query semantics — JSONB-style containment used for
-     * Postgres-flavoured equal/contains operators against decoded objects.
-     */
     private function matchesDocumentObject(mixed $value, Query $query): bool
     {
         $haystack = $this->decodeObjectishValue($value);
@@ -3303,7 +2822,7 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
         $method = $query->getMethod();
 
         switch ($method) {
-            case Query::TYPE_EQUAL:
+            case Method::Equal:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3315,7 +2834,7 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_NOT_EQUAL:
+            case Method::NotEqual:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3327,8 +2846,8 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
+            case Method::Contains:
+            case Method::ContainsAny:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3340,7 +2859,7 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
 
                 return false;
 
-            case Query::TYPE_CONTAINS_ALL:
+            case Method::ContainsAll:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3352,7 +2871,7 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_NOT_CONTAINS:
+            case Method::NotContains:
                 if ($haystack === null) {
                     return false;
                 }
@@ -3364,41 +2883,38 @@ private function matchesDocumentObject(mixed $value, Query $query): bool
 
                 return true;
 
-            case Query::TYPE_IS_NULL:
+            case Method::IsNull:
                 return $value === null;
 
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNotNull:
                 return $value !== null;
         }
 
-        throw new QueryException('Query method ' . $method . ' not supported for object attributes');
+        throw new QueryException('Query method '.$method->value.' not supported for object attributes');
     }
 
     /**
-     * Stable ordering across Documents. Random short-circuits via shuffle to
-     * preserve usort transitivity; absent attributes fall back to $sequence.
-     *
-     * @param  array<int, Document>  $documents
-     * @param  array<int, string>  $orderAttributes
-     * @param  array<int, string>  $orderTypes
+     * @param array<int, Document> $documents
+     * @param array<string> $orderAttributes
+     * @param array<OrderDirection> $orderTypes
      * @return array<int, Document>
      */
-    private function orderDocuments(array $documents, array $orderAttributes, array $orderTypes, string $cursorDirection): array
+    private function orderDocuments(array $documents, array $orderAttributes, array $orderTypes, CursorDirection $cursorDirection): array
     {
         foreach ($orderTypes as $type) {
-            if ($type === Database::ORDER_RANDOM) {
+            if ($type === OrderDirection::Random) {
                 \shuffle($documents);
 
                 return $documents;
             }
         }
 
-        $reverse = $cursorDirection === Database::CURSOR_BEFORE;
+        $reverse = $cursorDirection === CursorDirection::Before;
 
         if (empty($orderAttributes)) {
             \usort($documents, function (Document $a, Document $b) use ($reverse): int {
-                $av = $a->getAttribute('$sequence', 0);
-                $bv = $b->getAttribute('$sequence', 0);
+                $av = $a->getAttribute(Document::SEQUENCE, 0);
+                $bv = $b->getAttribute(Document::SEQUENCE, 0);
                 $av = \is_numeric($av) ? $av + 0 : 0;
                 $bv = \is_numeric($bv) ? $bv + 0 : 0;
                 if ($av === $bv) {
@@ -3414,11 +2930,11 @@ private function orderDocuments(array $documents, array $orderAttributes, array
 
         $directions = [];
         foreach ($orderAttributes as $i => $attribute) {
-            $direction = $orderTypes[$i] ?? Database::ORDER_ASC;
+            $direction = $orderTypes[$i] ?? OrderDirection::Asc;
             if ($reverse) {
-                $direction = $direction === Database::ORDER_ASC ? Database::ORDER_DESC : Database::ORDER_ASC;
+                $direction = $direction === OrderDirection::Asc ? OrderDirection::Desc : OrderDirection::Asc;
             }
-            $directions[$i] = $direction === Database::ORDER_ASC ? 1 : -1;
+            $directions[$i] = $direction === OrderDirection::Asc ? 1 : -1;
         }
 
         \usort($documents, function (Document $a, Document $b) use ($orderAttributes, $directions): int {
@@ -3446,35 +2962,33 @@ private function orderDocuments(array $documents, array $orderAttributes, array
     }
 
     /**
-     * Discard documents preceding the supplied cursor on the active sort.
-     *
-     * @param  array<int, Document>  $documents
-     * @param  array<int, string>  $orderAttributes
-     * @param  array<int, string>  $orderTypes
-     * @param  array<string, mixed>  $cursor
+     * @param array<int, Document> $documents
+     * @param array<string> $orderAttributes
+     * @param array<OrderDirection> $orderTypes
+     * @param array<string, mixed> $cursor
      * @return array<int, Document>
      */
-    private function cursorDocuments(array $documents, array $orderAttributes, array $orderTypes, array $cursor, string $cursorDirection): array
+    private function cursorDocuments(array $documents, array $orderAttributes, array $orderTypes, array $cursor, CursorDirection $cursorDirection): array
     {
         if (empty($cursor)) {
             return $documents;
         }
 
         if (empty($orderAttributes)) {
-            $orderAttributes = ['$sequence'];
-            $orderTypes = [Database::ORDER_ASC];
+            $orderAttributes = [Document::SEQUENCE];
+            $orderTypes = [OrderDirection::Asc];
         }
 
-        $reverse = $cursorDirection === Database::CURSOR_BEFORE;
+        $reverse = $cursorDirection === CursorDirection::Before;
         $resolved = [];
         foreach ($orderAttributes as $i => $attribute) {
-            $direction = $orderTypes[$i] ?? Database::ORDER_ASC;
+            $direction = $orderTypes[$i] ?? OrderDirection::Asc;
             if ($reverse) {
-                $direction = $direction === Database::ORDER_ASC ? Database::ORDER_DESC : Database::ORDER_ASC;
+                $direction = $direction === OrderDirection::Asc ? OrderDirection::Desc : OrderDirection::Asc;
             }
             $resolved[] = [
                 'attribute' => $attribute,
-                'asc' => $direction === Database::ORDER_ASC,
+                'asc' => $direction === OrderDirection::Asc,
                 'ref' => $cursor[$attribute] ?? null,
             ];
         }
@@ -3512,16 +3026,8 @@ private function cursorDocuments(array $documents, array $orderAttributes, array
         return $output;
     }
 
-    /**
-     * Resolve a dotted attribute path on a Document, falling back to nested
-     * decoded JSON traversal when the head segment holds a string payload.
-     */
     private function resolveDocumentAttribute(Document $document, string $attribute): mixed
     {
-        // Redis stores documents as raw JSON, so attribute keys keep symbols
-        // (`$`, `.`, etc.) verbatim. Try a direct lookup first — only when the
-        // literal key misses do we fall back to the filtered alias and then to
-        // dotted-path traversal (mirrors Memory's `resolveAttributeValue`).
         if ($document->offsetExists($attribute)) {
             return $document->getAttribute($attribute);
         }
@@ -3550,9 +3056,6 @@ private function resolveDocumentAttribute(Document $document, string $attribute)
         return $this->traverseNestedPath($value, $rest);
     }
 
-    /**
-     * Walk a remaining dotted path through arrays, returning null on miss.
-     */
     private function traverseNestedPath(mixed $value, string $path): mixed
     {
         foreach (\explode('.', $path) as $part) {
@@ -3571,15 +3074,14 @@ private function traverseNestedPath(mixed $value, string $path): mixed
         return $value;
     }
 
-    /**
-     * Normalise a value for unique-index hashing. Booleans collapse to ints
-     * and numeric strings collapse to numbers so signatures match SQL casts.
-     */
     private function normalizeIndexValue(mixed $value): mixed
     {
         if (\is_bool($value)) {
             return $value ? 1 : 0;
         }
+        if (\is_array($value)) {
+            return \json_encode($value);
+        }
         if (\is_string($value) && \is_numeric($value)) {
             return $value + 0;
         }
@@ -3587,10 +3089,6 @@ private function normalizeIndexValue(mixed $value): mixed
         return $value;
     }
 
-    /**
-     * Equal-with-numeric-coercion mirroring Memory::looseEquals — covers the
-     * "1" == 1 case Database tests rely on.
-     */
     private function valuesEqual(mixed $a, mixed $b): bool
     {
         if ($a === $b) {
@@ -3604,9 +3102,6 @@ private function valuesEqual(mixed $a, mixed $b): bool
     }
 
     /**
-     * Decode a CONTAINS-target into an array if possible. Returns null when
-     * the value is neither an array nor a JSON-encoded array string.
-     *
      * @return array<mixed>|null
      */
     private function coerceArrayValue(mixed $value): ?array
@@ -3623,9 +3118,6 @@ private function coerceArrayValue(mixed $value): ?array
         return null;
     }
 
-    /**
-     * Decode an object-typed attribute value for JSONB-style containment.
-     */
     private function decodeObjectishValue(mixed $value): mixed
     {
         if ($value === null) {
@@ -3647,10 +3139,6 @@ private function decodeObjectishValue(mixed $value): mixed
         return $value;
     }
 
-    /**
-     * Postgres `@>` JSONB containment in PHP — recursive subset semantics
-     * with list-element matching for array haystacks.
-     */
     private function jsonContainment(mixed $haystack, mixed $candidate): bool
     {
         if (\is_array($haystack) && \array_is_list($haystack)) {
@@ -3700,10 +3188,6 @@ private function jsonContainment(mixed $haystack, mixed $candidate): bool
         return false;
     }
 
-    /**
-     * Wrap `['skills' => 'typescript']` into `['skills' => ['typescript']]`
-     * so contains-style probes hit array entries inside the haystack.
-     */
     private function wrapScalarObjectCandidate(mixed $candidate): mixed
     {
         if (! \is_array($candidate) || \count($candidate) !== 1) {
@@ -3718,11 +3202,6 @@ private function wrapScalarObjectCandidate(mixed $candidate): mixed
         return [$key => [$value]];
     }
 
-    /**
-     * Natural-language fulltext approximation: tokenise on
-     * whitespace/punctuation, support trailing wildcard prefix matching, and
-     * honour quoted phrases as case-insensitive substring probes.
-     */
     private function matchesFulltextRedis(string $haystack, string $needle): bool
     {
         if (\preg_match('/^"(.*)"$/u', \trim($needle), $matches) === 1) {
@@ -3774,18 +3253,14 @@ private function tokenizeForSearch(string $text): array
     }
 
     /**
-     * Extract user-requested attributes from any TYPE_SELECT queries. Internal
-     * attributes (prefixed with `$` or `_`) are always preserved — only user
-     * attributes are subject to projection.
-     *
-     * @param  array<int, Query>  $queries
+     * @param array<Query> $queries
      * @return array<int, string>
      */
-    private function extractSelectionsFromQueries(array $queries): array
+    protected function extractSelections(array $queries): array
     {
         $selections = [];
         foreach ($queries as $query) {
-            if ($query->getMethod() !== Query::TYPE_SELECT) {
+            if ($query->getMethod() !== Method::Select) {
                 continue;
             }
             foreach ($query->getValues() as $value) {
@@ -3799,11 +3274,7 @@ private function extractSelectionsFromQueries(array $queries): array
     }
 
     /**
-     * Project a Document down to the supplied user-attribute selection.
-     * `*` short-circuits projection (no filter applied). Internal attributes
-     * (prefixed `$` / `_`) are always retained.
-     *
-     * @param  array<int, string>  $selections
+     * @param array<int, string> $selections
      */
     private function projectDocument(Document $document, array $selections): Document
     {
@@ -3813,7 +3284,7 @@ private function projectDocument(Document $document, array $selections): Documen
 
         $projected = [];
         foreach ($document->getArrayCopy() as $field => $value) {
-            if (\is_string($field) && (\str_starts_with($field, '$') || \str_starts_with($field, '_'))) {
+            if (\str_starts_with($field, '$') || \str_starts_with($field, '_')) {
                 $projected[$field] = $value;
 
                 continue;
@@ -3826,208 +3297,9 @@ private function projectDocument(Document $document, array $selections): Documen
         return new Document($projected);
     }
 
-    // === @architect:T40 end ===
-
-
-
-
-
-    // === @architect:T50 owns: permissions + relationships ===
-
-    public function createRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay = false, string $id = '', string $twoWayKey = ''): bool
-    {
-        // Redis stores documents as flexible JSON blobs, so the relationship
-        // "column" is registered on the collection's meta.attrs list rather
-        // than added as a physical schema column. Mirrors Memory's
-        // `registerRelationshipField` — minimal record only; the orchestrator
-        // writes the full options (onDelete / side / related-collection) onto
-        // the METADATA collection separately. The M2M junction collection
-        // itself is created by the wrapper via the standard createCollection
-        // path with explicit attributes.
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                $this->createAttribute($collection, $id, Database::VAR_RELATIONSHIP, 0, true, false, false);
-                if ($twoWay) {
-                    $this->createAttribute($relatedCollection, $twoWayKey, Database::VAR_RELATIONSHIP, 0, true, false, false);
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                $this->createAttribute($relatedCollection, $twoWayKey, Database::VAR_RELATIONSHIP, 0, true, false, false);
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                $this->createAttribute($collection, $id, Database::VAR_RELATIONSHIP, 0, true, false, false);
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                // Junction columns live on the junction collection, which is
-                // created with explicit attributes by the wrapper.
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
-
-        return true;
-    }
-
-    public function updateRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side, ?string $newKey = null, ?string $newTwoWayKey = null): bool
-    {
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
-        $newKey = $newKey !== null ? $this->filter($newKey) : null;
-        $newTwoWayKey = $newTwoWayKey !== null ? $this->filter($newTwoWayKey) : null;
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($newKey !== null && $newKey !== $key) {
-                    $this->renameAttribute($collection, $key, $newKey);
-                }
-                if ($twoWay && $newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
-                    $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
-                        $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
-                    }
-                } else {
-                    if ($newKey !== null && $newKey !== $key) {
-                        $this->renameAttribute($collection, $key, $newKey);
-                    }
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
-                        $this->renameAttribute($relatedCollection, $twoWayKey, $newTwoWayKey);
-                    }
-                } else {
-                    if ($newKey !== null && $newKey !== $key) {
-                        $this->renameAttribute($collection, $key, $newKey);
-                    }
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $junction = $this->resolveJunctionCollection($collection, $relatedCollection, $side);
-                if ($junction !== null) {
-                    if ($newKey !== null && $newKey !== $key) {
-                        $this->renameAttribute($junction, $key, $newKey);
-                    }
-                    if ($newTwoWayKey !== null && $newTwoWayKey !== $twoWayKey) {
-                        $this->renameAttribute($junction, $twoWayKey, $newTwoWayKey);
-                    }
-                }
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
-
-        return true;
-    }
-
-    public function deleteRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side): bool
-    {
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
-
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $this->deleteAttribute($collection, $key);
-                    if ($twoWay) {
-                        $this->deleteAttribute($relatedCollection, $twoWayKey);
-                    }
-                } else {
-                    $this->deleteAttribute($relatedCollection, $twoWayKey);
-                    if ($twoWay) {
-                        $this->deleteAttribute($collection, $key);
-                    }
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $this->deleteAttribute($relatedCollection, $twoWayKey);
-                } else {
-                    $this->deleteAttribute($collection, $key);
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $this->deleteAttribute($collection, $key);
-                } else {
-                    $this->deleteAttribute($relatedCollection, $twoWayKey);
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                // Junction collection is dropped by the wrapper via cleanupCollection.
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
-
-        return true;
-    }
-
-    // === @architect:T50 end ===
-
-
-
-
-
-    // === @architect:T56 owns: transactions + journal ===
-
-    public function startTransaction(): bool
-    {
-        $this->journalStack[] = [];
-        $this->inTransaction++;
-
-        return true;
-    }
-
-    public function commitTransaction(): bool
-    {
-        if ($this->inTransaction === 0) {
-            return false;
-        }
-
-        $this->commitJournal();
-        $this->inTransaction--;
-
-        return true;
-    }
-
-    public function rollbackTransaction(): bool
-    {
-        if ($this->inTransaction === 0) {
-            return false;
-        }
-
-        try {
-            $this->rollbackJournal();
-            $this->inTransaction--;
-        } catch (\Throwable $e) {
-            // A failed rollback (mid-replay) leaves the transaction in an
-            // indeterminate state. Discard all pending journal state so the
-            // connection is clean for reuse. Both must be cleared together to
-            // preserve the count($journalStack) === inTransaction invariant:
-            // resetting only the counter would strand parent frames that later
-            // transactions merge into, growing the stack without bound.
-            $this->inTransaction = 0;
-            $this->journalStack = [];
-            throw $e;
-        }
-
-        return true;
-    }
-
-    // === @architect:T56 end ===
-
     /**
-     * Resolve any Operator-typed attributes against the existing document
-     * before persisting. Mirrors Memory::applyOperators — non-operator
-     * values pass through untouched.
-     *
-     * @param  array<string, mixed>  $attrs  Incoming attributes (may contain Operator instances)
-     * @param  array<string, mixed>  $existing  Decoded document used as the operator's "current" value
+     * @param array<string, mixed> $attrs
+     * @param array<string, mixed> $existing
      * @return array<string, mixed>
      */
     protected function applyOperators(array $attrs, array $existing): array
@@ -4046,138 +3318,117 @@ protected function applyOperators(array $attrs, array $existing): array
         return $result;
     }
 
-    /**
-     * Apply a single Operator to a stored value and return the new value.
-     * Mirrors Memory::applyOperator — the SQL adapters express the same
-     * semantics in CASE/JSON helpers (see MariaDB::getOperatorSQL).
-     */
     protected function applyOperator(mixed $current, Operator $operator): mixed
     {
         $values = $operator->getValues();
         $method = $operator->getMethod();
+        $exact = BigInt::calculateOutsideNative($method, $current ?? 0, $values[0] ?? 1);
+        if ($exact !== null) {
+            $bound = $values[1] ?? null;
+            if ($method === OperatorType::Modulo || ! BigInt::isIntegerValue($bound)) {
+                return $exact;
+            }
+
+            return $this->applyNumericLimit(
+                $current ?? 0,
+                $exact,
+                $bound,
+                \in_array($method, [OperatorType::Increment, OperatorType::Multiply, OperatorType::Power], true)
+            );
+        }
 
         switch ($method) {
-            case Operator::TYPE_INCREMENT:
-                $by = $values[0] ?? 1;
+            case OperatorType::Increment:
+                $by = $this->numericOr($values[0] ?? 1, 1);
                 $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($max !== null) {
-                    // Guard: if the RESULT would exceed the max, leave it unchanged. Comparing
-                    // remaining headroom keeps us inside PHP's int range. Must NOT short-circuit
-                    // on `$base >= $max` — a negative $by moves the value down, so an over-max
-                    // base can still land within bound (e.g. 52 + (-5) = 47 <= 50 must apply).
-                    if (($max - $base) < $by) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                }
+                $base = $this->numericOr($current, 0);
 
-                return $this->preserveNumericType($base, $base + $by);
+                return $this->applyNumericLimit($base, $base + $by, $max, true);
 
-            case Operator::TYPE_DECREMENT:
-                $by = $values[0] ?? 1;
+            case OperatorType::Decrement:
+                $by = $this->numericOr($values[0] ?? 1, 1);
                 $min = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($min !== null) {
-                    // Guard: leave unchanged only if the RESULT would go below min. Don't
-                    // short-circuit on `$base <= $min` — a negative $by moves the value up.
-                    if (($base - $min) < $by) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                }
+                $base = $this->numericOr($current, 0);
 
-                return $this->preserveNumericType($base, $base - $by);
+                return $this->applyNumericLimit($base, $base - $by, $min, false);
 
-            case Operator::TYPE_MULTIPLY:
-                $by = $values[0] ?? 1;
+            case OperatorType::Multiply:
+                $by = $this->numericOr($values[0] ?? 1, 1);
                 $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                $result = $base * $by;
-                if ($max !== null && $result > $max) {
-                    return $this->preserveNumericType($base, $base);
-                }
+                $base = $this->numericOr($current, 0);
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($base, $base * $by, $max, true);
 
-            case Operator::TYPE_DIVIDE:
+            case OperatorType::Divide:
                 $by = $values[0] ?? 1;
                 $min = $values[1] ?? null;
-                if ($by == 0) {
+                if (! \is_numeric($by) || $by == 0) {
                     return $current;
                 }
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                $result = $base / $by;
-                if ($min !== null && $result < $min) {
-                    return $this->preserveNumericType($base, $base);
-                }
+                $base = $this->numericOr($current, 0);
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($base, $base / ($by + 0), $min, false);
 
-            case Operator::TYPE_MODULO:
+            case OperatorType::Modulo:
                 $by = $values[0] ?? 1;
-                if ($by == 0) {
+                if (! \is_numeric($by) || $by == 0) {
                     return $current;
                 }
                 $base = \is_numeric($current) ? (int) $current : 0;
 
                 return $base % (int) $by;
 
-            case Operator::TYPE_POWER:
-                $by = $values[0] ?? 1;
+            case OperatorType::Power:
+                $by = $this->numericOr($values[0] ?? 1, 1);
                 $max = $values[1] ?? null;
-                $base = \is_numeric($current) ? $current + 0 : 0;
-                if ($max !== null) {
-                    // Leave the value unchanged for undefined inputs (0 to a negative power, or a
-                    // negative base to a fractional exponent) — they produce INF/NaN, not a number.
-                    if (($base == 0 && $by < 0) || ($base < 0 && \floor($by) != $by)) {
-                        return $this->preserveNumericType($base, $base);
-                    }
-                    $result = $base ** $by;
-                    // A result that overflows (INF) or exceeds the max also leaves the value as-is.
-                    if (!\is_finite($result) || $result > $max) {
-                        return $this->preserveNumericType($base, $base);
+                $base = $this->numericOr($current, 0);
+                if (($base == 0 && $by < 0) || ($base < 0 && \floor($by) != $by)) {
+                    if (\is_numeric($max)) {
+                        return $base;
                     }
 
-                    return $this->preserveNumericType($base, $result);
+                    throw new LimitException('Value out of range');
                 }
 
-                // 0 to a negative power, or a negative base to a fractional exponent, is not a real
-                // number. Fail loudly with a clear exception rather than storing INF/NaN (which
-                // also can't be JSON-encoded, so it would otherwise surface as a raw JsonException).
-                $result = $base ** $by;
-                if (!\is_finite($result)) {
+                $candidate = $base ** $by;
+                if (! \is_finite((float) $candidate)) {
+                    if (\is_numeric($max)) {
+                        return $base;
+                    }
+
                     throw new LimitException('Value out of range');
                 }
 
-                return $this->preserveNumericType($base, $result);
+                return $this->applyNumericLimit($base, $candidate, $max, true);
 
-            case Operator::TYPE_STRING_CONCAT:
-                return ((string) ($current ?? '')) . (string) ($values[0] ?? '');
+            case OperatorType::StringConcat:
+                return $this->stringOrEmpty($current).$this->stringOrEmpty($values[0] ?? '');
 
-            case Operator::TYPE_STRING_REPLACE:
-                $search = (string) ($values[0] ?? '');
-                $replace = (string) ($values[1] ?? '');
+            case OperatorType::StringReplace:
+                $search = $this->stringOrEmpty($values[0] ?? '');
+                $replace = $this->stringOrEmpty($values[1] ?? '');
                 if ($current === null) {
                     return null;
                 }
 
-                return \str_replace($search, $replace, (string) $current);
+                return \str_replace($search, $replace, $this->stringOrEmpty($current));
 
-            case Operator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 return ! (bool) $current;
 
-            case Operator::TYPE_ARRAY_APPEND:
+            case OperatorType::ArrayAppend:
                 $list = $this->coerceArray($current);
 
                 return [...$list, ...\array_values($values)];
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayPrepend:
                 $list = $this->coerceArray($current);
 
                 return [...\array_values($values), ...$list];
 
-            case Operator::TYPE_ARRAY_INSERT:
+            case OperatorType::ArrayInsert:
                 $list = $this->coerceArray($current);
-                $index = (int) ($values[0] ?? 0);
+                $index = $this->intOr($values[0] ?? 0, 0);
                 $value = $values[1] ?? null;
                 if ($index < 0) {
                     $index = 0;
@@ -4189,67 +3440,74 @@ protected function applyOperator(mixed $current, Operator $operator): mixed
 
                 return $list;
 
-            case Operator::TYPE_ARRAY_REMOVE:
+            case OperatorType::ArrayRemove:
                 $list = $this->coerceArray($current);
                 $needle = $values[0] ?? null;
 
                 return \array_values(\array_filter($list, fn ($item) => $item !== $needle));
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 $list = $this->coerceArray($current);
 
                 return \array_values(\array_unique($list, SORT_REGULAR));
 
-            case Operator::TYPE_ARRAY_INTERSECT:
+            case OperatorType::ArrayIntersect:
                 $list = $this->coerceArray($current);
                 $other = \array_values($values);
 
                 return \array_values(\array_filter($list, fn ($item) => \in_array($item, $other, false)));
 
-            case Operator::TYPE_ARRAY_DIFF:
+            case OperatorType::ArrayDiff:
                 $list = $this->coerceArray($current);
                 $other = \array_values($values);
 
                 return \array_values(\array_filter($list, fn ($item) => ! \in_array($item, $other, false)));
 
-            case Operator::TYPE_ARRAY_FILTER:
+            case OperatorType::ArrayFilter:
                 $list = $this->coerceArray($current);
-                $condition = (string) ($values[0] ?? '');
+                $condition = $this->stringOrEmpty($values[0] ?? '');
                 $compare = $values[1] ?? null;
 
                 return \array_values(\array_filter($list, fn ($item) => $this->matchesArrayFilter($item, $condition, $compare)));
 
-            case Operator::TYPE_DATE_ADD_DAYS:
-                $days = (int) ($values[0] ?? 0);
+            case OperatorType::DateAddDays:
+                $days = $this->intOr($values[0] ?? 0, 0);
 
                 return $this->shiftDate($current, $days * 86400);
 
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $days = (int) ($values[0] ?? 0);
+            case OperatorType::DateSubDays:
+                $days = $this->intOr($values[0] ?? 0, 0);
 
                 return $this->shiftDate($current, -$days * 86400);
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return DateTime::now();
         }
-
-        throw new OperatorException("Invalid operator: {$method}");
     }
 
-    protected function applyNumericLimit(int|float $value, int|float|null $bound, bool $isUpper): int|float
+    protected function applyNumericLimit(mixed $original, mixed $candidate, mixed $bound, bool $isUpper): int|float|string
     {
-        if ($bound === null) {
-            return $value;
+        if (BigInt::isIntegerValue($original) && BigInt::isIntegerValue($candidate) && BigInt::isIntegerValue($bound)) {
+            $crossed = $isUpper
+                ? BigInt::compare($candidate, $bound) > 0
+                : BigInt::compare($candidate, $bound) < 0;
+
+            return $crossed ? BigInt::toNative($original) : BigInt::toNative($candidate);
+        }
+
+        $numericOriginal = \is_numeric($original) ? $original + 0 : 0;
+        $numericCandidate = \is_numeric($candidate) ? $candidate + 0 : 0;
+
+        if (\is_numeric($bound)) {
+            $numericBound = $bound + 0;
+            if (($isUpper && $numericCandidate > $numericBound) || (! $isUpper && $numericCandidate < $numericBound)) {
+                return $numericOriginal;
+            }
         }
 
-        return $isUpper ? \min($value, $bound) : \max($value, $bound);
+        return $this->preserveNumericType($numericOriginal, $numericCandidate);
     }
 
-    /**
-     * Preserve int-ness when the original value is an int — without this,
-     * PHP's arithmetic promotes the result to float and the Range validator
-     * rejects an integer column post-update.
-     */
     protected function preserveNumericType(int|float $original, int|float $result): int|float
     {
         if (\is_int($original) && \is_float($result) && $result === (float) (int) $result) {
@@ -4280,14 +3538,14 @@ protected function coerceArray(mixed $value): array
     protected function matchesArrayFilter(mixed $item, string $condition, mixed $compare): bool
     {
         return match ($condition) {
-            Query::TYPE_EQUAL => $item == $compare,
-            Query::TYPE_NOT_EQUAL => $item != $compare,
-            Query::TYPE_GREATER => \is_numeric($item) && \is_numeric($compare) && $item + 0 > $compare + 0,
-            Query::TYPE_GREATER_EQUAL => \is_numeric($item) && \is_numeric($compare) && $item + 0 >= $compare + 0,
-            Query::TYPE_LESSER => \is_numeric($item) && \is_numeric($compare) && $item + 0 < $compare + 0,
-            Query::TYPE_LESSER_EQUAL => \is_numeric($item) && \is_numeric($compare) && $item + 0 <= $compare + 0,
-            Query::TYPE_IS_NULL => $item === null,
-            Query::TYPE_IS_NOT_NULL => $item !== null,
+            Method::Equal->value => $item == $compare,
+            Method::NotEqual->value => $item != $compare,
+            Method::GreaterThan->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 > $compare + 0,
+            Method::GreaterThanEqual->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 >= $compare + 0,
+            Method::LessThan->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 < $compare + 0,
+            Method::LessThanEqual->value => \is_numeric($item) && \is_numeric($compare) && $item + 0 <= $compare + 0,
+            Method::IsNull->value => $item === null,
+            Method::IsNotNull->value => $item !== null,
             default => true,
         };
     }
@@ -4297,12 +3555,13 @@ protected function shiftDate(mixed $current, int $seconds): ?string
         if ($current === null) {
             return null;
         }
+        $stringified = $this->stringOrEmpty($current);
         try {
-            $base = new \DateTime((string) $current);
+            $base = new \DateTime($stringified);
         } catch (\Throwable) {
-            return $current === '' ? null : (string) $current;
+            return $stringified === '' ? null : $stringified;
         }
-        $base->modify(($seconds >= 0 ? '+' : '') . $seconds . ' seconds');
+        $base->modify(($seconds >= 0 ? '+' : '').$seconds.' seconds');
 
         return DateTime::format($base);
     }
diff --git a/src/Database/Adapter/SQL.php b/src/Database/Adapter/SQL.php
index 2d6043980f..a83228a552 100644
--- a/src/Database/Adapter/SQL.php
+++ b/src/Database/Adapter/SQL.php
@@ -3,32 +3,219 @@
 namespace Utopia\Database\Adapter;
 
 use Exception;
+use PDO;
 use PDOException;
+use PDOStatement;
+use Swoole\Database\PDOProxy;
+use Swoole\Database\PDOStatementProxy;
+use Throwable;
 use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Change;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Hook\PermissionAllowNullUid;
+use Utopia\Database\Hook\PermissionFilter;
+use Utopia\Database\Hook\PermissionJoinFilter;
+use Utopia\Database\Hook\Permissions;
+use Utopia\Database\Hook\Tenancy;
+use Utopia\Database\Hook\TenantFilter;
+use Utopia\Database\Hook\WriteContext;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PDO as DatabasePDO;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
-
-abstract class SQL extends Adapter
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Query\Builder\Feature\FullOuterJoins as FullOuterJoinsFeature;
+use Utopia\Query\Builder\Feature\InsertOrIgnore as InsertOrIgnoreFeature;
+use Utopia\Query\Builder\Feature\Upsert as UpsertFeature;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\Builder\Statement;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Exception\UnsupportedException;
+use Utopia\Query\Exception\ValidationException;
+use Utopia\Query\Hook\Attribute\Map as AttributeMap;
+use Utopia\Query\Method;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema;
+use Utopia\Query\Schema\Column;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\MySQL as MySQLSchema;
+use Utopia\Query\Schema\PostgreSQL as PostgreSQLSchema;
+use Utopia\Query\Schema\Table;
+use Utopia\Query\Schema\Table\MySQL as MySQLTable;
+use Utopia\Query\Schema\Table\PostgreSQL as PostgreSQLTable;
+
+/**
+ * Abstract base adapter for SQL-based database engines (MariaDB, MySQL, PostgreSQL, SQLite).
+ */
+abstract class SQL extends Adapter implements Feature\RawQuery, Feature\QueryBuilder, Feature\ColumnTypes, Feature\Relationships, Feature\Upserts
 {
-    protected const VECTOR_DISTANCE_COLUMN = '_distance';
+    private const string FOJ_ORDER_ALIAS_PREFIX = 'foj_ord_';
 
-    protected mixed $pdo;
+    protected object $pdo;
 
     /**
      * Controls how many fractional digits are used when binding float parameters.
      */
     protected int $floatPrecision = 17;
 
+    /**
+     * Memoized spatial column ids, keyed by database/namespace/collection so
+     * that Pool sibling adapters reusing the same instance across tenants
+     * never cross-contaminate. The cached entry also stores an attribute
+     * fingerprint so a long-lived process (Appwrite API workers) that added
+     * spatial columns after the first write still rescans instead of serving
+     * a stale empty list. Explicitly invalidated on schema mutations via
+     * invalidateSpatialAttributesCache().
+     *
+     * @var array<string, array{fingerprint: string, attributes: list<string>}>
+     */
+    private array $spatialAttributesCache = [];
+
+    /**
+     * Lazily constructed AttributeMap shared by every newBuilder() call.
+     * AttributeMap is a readonly stateless config object, so it can safely
+     * be reused across queries on the same adapter.
+     */
+    private ?AttributeMap $attributeMap = null;
+
+    /**
+     * @var \WeakMap<object, Event>|null
+     */
+    private ?\WeakMap $statementEvents = null;
+
+    /**
+     * Bind builder-produced positional parameters onto a prepared statement.
+     *
+     * Centralises the find / count / sum binding loops so the
+     * IntegerBooleans capability check is resolved once per call rather
+     * than once per binding. Mirrors the find() superset (handles arrays
+     * via json_encode, floats via float-precision string binding, and
+     * booleans via int coercion when the adapter expects integers).
+     *
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
+     * @param  array<int, mixed>  $bindings
+     */
+    protected function bindStatement(PDOStatement|DatabasePDOStatement|PDOStatementProxy $stmt, array $bindings): void
+    {
+        $intBools = $this->supports(Capability::IntegerBooleans);
+
+        foreach ($bindings as $i => $value) {
+            if ($intBools && \is_bool($value)) {
+                $value = (int) $value;
+            }
+            if (\is_array($value)) {
+                $value = \json_encode($value);
+            }
+            if (\is_float($value)) {
+                $stmt->bindValue($i + 1, $this->getFloatPrecision($value), PDO::PARAM_STR);
+            } else {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
+            }
+        }
+    }
+
+    /**
+     * Accepts Utopia\Database\PDO, a PDO-compatible proxy, or a native PDO.
+     */
+    public function __construct(object $pdo)
+    {
+        $this->pdo = $pdo;
+    }
+
+    /**
+     * Get the list of capabilities supported by SQL adapters.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::Schemas,
+            Capability::BoundaryInclusive,
+            Capability::Caching,
+            Capability::Fulltext,
+            Capability::MultipleFulltextIndexes,
+            Capability::Regex,
+            Capability::Casting,
+            Capability::UpdateLock,
+            Capability::BatchOperations,
+            Capability::BatchCreateAttributes,
+            Capability::TransactionRetries,
+            Capability::NestedTransactions,
+            Capability::QueryContains,
+            Capability::Operators,
+            Capability::OrderRandom,
+            Capability::IdenticalIndexes,
+            Capability::Reconnection,
+            Capability::CacheSkipOnFailure,
+            Capability::Hostname,
+            Capability::AttributeResizing,
+            Capability::DefinedAttributes,
+            Capability::Joins,
+            Capability::Aggregations,
+        ]);
+    }
+
+    /**
+     * Returns the current PDO object
+     *
+     * @deprecated Use getDriver() instead
+     */
+    protected function getPDO(): DatabasePDO|PDOProxy|PDO
+    {
+        if ($this->pdo instanceof DatabasePDO || $this->pdo instanceof PDOProxy || $this->pdo instanceof PDO) {
+            return $this->pdo;
+        }
+
+        throw new DatabaseException('SQL adapter requires Utopia\\Database\\PDO, Swoole\\Database\\PDOProxy, or PDO');
+    }
+
+    /**
+     * Returns the current PDO object
+     */
+    public function getDriver(): DatabasePDO|PDOProxy|PDO
+    {
+        return $this->getPDO();
+    }
+
+    /**
+     * Returns default PDO configuration
+     *
+     * @return array<int, mixed>
+     */
+    public static function getPDOAttributes(): array
+    {
+        return [
+            PDO::ATTR_TIMEOUT => 3, // Specifies the timeout duration in seconds. Takes a value of type int.
+            PDO::ATTR_PERSISTENT => true, // Create a persistent connection
+            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // Fetch a result row as an associative array.
+            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // PDO will throw a PDOException on errors
+            PDO::ATTR_EMULATE_PREPARES => true, // Emulate prepared statements
+            PDO::ATTR_STRINGIFY_FETCHES => true, // Returns all fetched data as Strings
+        ];
+    }
+
     /**
      * Configure float precision for parameter binding/logging.
      */
@@ -42,7 +229,7 @@ public function setFloatPrecision(int $precision): void
      */
     protected function getFloatPrecision(float $value): string
     {
-        return sprintf('%.'. $this->floatPrecision . 'F', $value);
+        return sprintf('%.'.$this->floatPrecision.'F', $value);
     }
 
     /**
@@ -58,19 +245,87 @@ protected function getSQLConditionsForCollection(string $name, array $queries, a
     }
 
     /**
-     * Constructor.
+     * Get the hostname of the database connection.
      *
-     * Set connection and settings
+     * @return string
+     */
+    public function getHostname(): string
+    {
+        try {
+            if ($this->pdo instanceof DatabasePDO) {
+                return $this->pdo->getHostname();
+            }
+
+            return $this->hostname;
+        } catch (Throwable) {
+            return '';
+        }
+    }
+
+    /**
+     * Get the internal ID attribute type used by SQL adapters.
      *
-     * @param mixed $pdo
+     * @return string
      */
-    public function __construct(mixed $pdo)
+    public function getIdAttributeType(): string
     {
-        $this->pdo = $pdo;
+        return ColumnType::Integer->value;
+    }
+
+    /**
+     * Set whether the adapter supports attribute definitions. Always true for SQL.
+     *
+     * @param bool $support Whether to enable attribute support
+     * @return bool
+     */
+    public function setSupportForAttributes(bool $support): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get the ALTER TABLE lock type clause for concurrent DDL operations.
+     *
+     * @return string
+     */
+    public function getLockType(): string
+    {
+        if ($this->supports(Capability::AlterLock) && $this->alterLocks) {
+            return ',LOCK=SHARED';
+        }
+
+        return '';
+    }
+
+    /**
+     * Ping Database
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function ping(): bool
+    {
+        $result = $this->createBuilder()->fromNone()->selectRaw('1')->build();
+
+        return $this->prepareStatement($result->query)->execute();
+    }
+
+    /**
+     * Reconnect to the database and reset the transaction counter.
+     *
+     * @return void
+     */
+    public function reconnect(): void
+    {
+        $pdo = $this->getPDO();
+        if ($pdo instanceof DatabasePDO) {
+            $pdo->reconnect();
+        }
+        $this->inTransaction = 0;
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function startTransaction(): bool
     {
@@ -81,7 +336,7 @@ public function startTransaction(): bool
                         $this->getPDO()->rollBack();
                     } else {
                         // If no active transaction, this has no effect.
-                        $this->getPDO()->prepare('ROLLBACK')->execute();
+                        $this->prepareStatement('ROLLBACK')->execute();
                     }
                 } catch (PDOException) {
                     // A pooled connection can report a transaction it no longer
@@ -90,13 +345,18 @@ public function startTransaction(): bool
                     // effort; swallow it and begin a fresh transaction below.
                 }
 
-                $this->getPDO()->beginTransaction();
+                $result = $this->getPDO()->beginTransaction();
 
             } else {
-                $this->getPDO()->exec('SAVEPOINT transaction' . $this->inTransaction);
+                $this->getPDO()->exec('SAVEPOINT transaction'.$this->inTransaction);
+                $result = true;
             }
         } catch (PDOException $e) {
-            throw new TransactionException('Failed to start transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new TransactionException('Failed to start transaction: '.$e->getMessage(), $e->getCode(), $e);
+        }
+
+        if ($result !== true) {
+            throw new TransactionException('Failed to start transaction');
         }
 
         $this->inTransaction++;
@@ -105,7 +365,7 @@ public function startTransaction(): bool
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function commitTransaction(): bool
     {
@@ -113,13 +373,15 @@ public function commitTransaction(): bool
             return false;
         }
 
-        if (!$this->getPDO()->inTransaction()) {
+        if (! $this->getPDO()->inTransaction()) {
             $this->inTransaction = 0;
+
             return false;
         }
 
         if ($this->inTransaction > 1) {
             $this->inTransaction--;
+
             return true;
         }
 
@@ -127,10 +389,10 @@ public function commitTransaction(): bool
             $result = $this->getPDO()->commit();
             $this->inTransaction = 0;
         } catch (PDOException $e) {
-            throw new TransactionException('Failed to commit transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new TransactionException('Failed to commit transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
 
-        if (!$result) {
+        if (! $result) {
             throw new TransactionException('Failed to commit transaction');
         }
 
@@ -138,7 +400,7 @@ public function commitTransaction(): bool
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function rollbackTransaction(): bool
     {
@@ -148,74 +410,59 @@ public function rollbackTransaction(): bool
 
         try {
             if ($this->inTransaction > 1) {
-                $this->getPDO()->exec('ROLLBACK TO transaction' . ($this->inTransaction - 1));
+                $this->getPDO()->exec('ROLLBACK TO transaction'.($this->inTransaction - 1));
                 $this->inTransaction--;
+                $result = true;
             } else {
-                $this->getPDO()->rollBack();
+                $result = $this->getPDO()->rollBack();
                 $this->inTransaction = 0;
             }
         } catch (PDOException $e) {
             $this->inTransaction = 0;
-            throw new DatabaseException('Failed to rollback transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new DatabaseException('Failed to rollback transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
 
-        return true;
-    }
-
-    /**
-     * Ping Database
-     *
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    public function ping(): bool
-    {
-        return $this->getPDO()
-            ->prepare("SELECT 1;")
-            ->execute();
-    }
+        if ($result !== true) {
+            throw new TransactionException('Failed to rollback transaction');
+        }
 
-    public function reconnect(): void
-    {
-        $this->getPDO()->reconnect();
-        $this->inTransaction = 0;
+        return true;
     }
 
     /**
      * Check if Database exists
      * Optionally check if collection exists in Database
      *
-     * @param string $database
-     * @param string|null $collection
-     * @return bool
      * @throws DatabaseException
      */
     public function exists(string $database, ?string $collection = null): bool
     {
         $database = $this->filter($database);
 
-        if (!\is_null($collection)) {
+        if (! \is_null($collection)) {
             $collection = $this->filter($collection);
-            $stmt = $this->getPDO()->prepare("
-                SELECT TABLE_NAME 
-                FROM INFORMATION_SCHEMA.TABLES 
-                WHERE TABLE_SCHEMA = :schema 
-                  AND TABLE_NAME = :table
-            ");
-            $stmt->bindValue(':schema', $database, \PDO::PARAM_STR);
-            $stmt->bindValue(':table', "{$this->getNamespace()}_{$collection}", \PDO::PARAM_STR);
+            $builder = $this->createBuilder();
+            $result = $builder
+                ->from('INFORMATION_SCHEMA.TABLES')
+                ->selectRaw('TABLE_NAME')
+                ->filter([
+                    BaseQuery::equal('TABLE_SCHEMA', [$database]),
+                    BaseQuery::equal('TABLE_NAME', ["{$this->getNamespace()}_{$collection}"]),
+                ])
+                ->build();
+            $stmt = $this->executeResult($result, Event::CollectionRead);
         } else {
-            $stmt = $this->getPDO()->prepare("
-                SELECT SCHEMA_NAME FROM
-                INFORMATION_SCHEMA.SCHEMATA
-                WHERE SCHEMA_NAME = :schema
-            ");
-            $stmt->bindValue(':schema', $database, \PDO::PARAM_STR);
+            $builder = $this->createBuilder();
+            $result = $builder
+                ->from('INFORMATION_SCHEMA.SCHEMATA')
+                ->selectRaw('SCHEMA_NAME')
+                ->filter([BaseQuery::equal('SCHEMA_NAME', [$database])])
+                ->build();
+            $stmt = $this->executeResult($result, Event::DatabaseList);
         }
 
         try {
-            $stmt->execute();
+            $this->execute($stmt);
             $document = $stmt->fetchAll();
             $stmt->closeCursor();
         } catch (PDOException $e) {
@@ -248,27 +495,32 @@ public function list(): array
     /**
      * Create Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): bool
+    public function createAttribute(string $collection, Attribute $attribute): bool
+    {
+        return $this->createAttributeWithEvent($collection, $attribute, Event::AttributeCreate);
+    }
+
+    protected function createAttributeWithEvent(string $collection, Attribute $attribute, Event $event): bool
     {
-        $id = $this->quote($this->filter($id));
-        $type = $this->getSQLType($type, $size, $signed, $array, $required);
-        $sql = "ALTER TABLE {$this->getSQLTable($collection)} ADD COLUMN {$id} {$type} {$this->getLockType()};";
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $this->addTableColumn($table, $attribute->key, $attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        $result = $table->alter();
+
+        $sql = $result->query;
+        $lockType = $this->getLockType();
+        if (! empty($lockType)) {
+            $sql = rtrim($sql, ';').' '.$lockType;
+        }
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            $ok = $this->executeStatement($sql, $event);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -277,89 +529,88 @@ public function createAttribute(string $collection, string $id, string $type, in
     /**
      * Create Attributes
      *
-     * @param string $collection
-     * @param array<array<string, mixed>> $attributes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     *
      * @throws DatabaseException
      */
     public function createAttributes(string $collection, array $attributes): bool
     {
-        $parts = [];
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
         foreach ($attributes as $attribute) {
-            $id = $this->quote($this->filter($attribute['$id']));
-            $type = $this->getSQLType(
-                $attribute['type'],
-                $attribute['size'],
-                $attribute['signed'] ?? true,
-                $attribute['array'] ?? false,
-                $attribute['required'] ?? false,
+            $this->addTableColumn(
+                $table,
+                $attribute->key,
+                $attribute->type,
+                $attribute->size,
+                $attribute->signed,
+                $attribute->array,
+                $attribute->required,
             );
-            $parts[] = "{$id} {$type}";
         }
+        $result = $table->alter();
 
-        $columns = \implode(', ADD COLUMN ', $parts);
-
-        $sql = "ALTER TABLE {$this->getSQLTable($collection)} ADD COLUMN {$columns} {$this->getLockType()};";
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+        $sql = $result->query;
+        $lockType = $this->getLockType();
+        if (! empty($lockType)) {
+            $sql = rtrim($sql, ';').' '.$lockType;
+        }
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            $ok = $this->executeStatement($sql, Event::AttributesCreate);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
     }
 
     /**
-     * Rename Attribute
+     * Delete Attribute
      *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function renameAttribute(string $collection, string $old, string $new): bool
+    public function deleteAttribute(string $collection, string $id): bool
     {
-        $collection = $this->filter($collection);
-        $old = $this->quote($this->filter($old));
-        $new = $this->quote($this->filter($new));
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $table->dropColumn($this->filter($id));
+        $result = $table->alter();
 
-        $sql = "ALTER TABLE {$this->getSQLTable($collection)} RENAME COLUMN {$old} TO {$new};";
-
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+        $sql = $result->query;
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            $ok = $this->executeStatement($sql, Event::AttributeDelete);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
     }
 
     /**
-     * Delete Attribute
+     * Rename Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param bool $array
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function deleteAttribute(string $collection, string $id, bool $array = false): bool
+    public function renameAttribute(string $collection, string $old, string $new): bool
     {
-        $id = $this->quote($this->filter($id));
-        $sql = "ALTER TABLE {$this->getSQLTable($collection)} DROP COLUMN {$id};";
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $sql);
+        $schema = $this->createSchemaBuilder();
+        $table = $schema->table($this->getSQLTableRaw($collection));
+        $table->renameColumn($this->filter($old), $this->filter($new));
+        $result = $table->alter();
+
+        $sql = $result->query;
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            $ok = $this->executeStatement($sql, Event::AttributeUpdate);
+            $this->invalidateSpatialAttributesCache($collection);
+
+            return $ok;
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -368,424 +619,484 @@ public function deleteAttribute(string $collection, string $id, bool $array = fa
     /**
      * Get Document
      *
-     * @param Document $collection
-     * @param string $id
-     * @param Query[] $queries
-     * @param bool $forUpdate
-     * @return Document
+     * @param  Query[]  $queries
+     *
      * @throws DatabaseException
      */
     public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
     {
+        $collectionDoc = $collection;
         $collection = $collection->getId();
 
         $name = $this->filter($collection);
         $selections = $this->getAttributeSelections($queries);
+        $alias = Query::DEFAULT_ALIAS;
+
+        // Fast path: single-row lookup by primary key with no projection,
+        // no shared-tenant filter, no joins, and no row lock. This is by far
+        // the most common shape (metadata fetch, primary cache miss, etc.);
+        // skip the builder pipeline and go directly to a parameterised SELECT.
+        if (
+            empty($selections)
+            && ! $forUpdate
+            && ! ($this->sharedTables && $this->tenant !== null)
+            && ! $this->queriesHaveJoins($queries)
+        ) {
+            $tableExpr = $this->getSQLTable($name);
+            $aliasQuoted = $this->quote($alias);
+            $uidQuoted = $this->quote(Storage::UID);
+            $sql = "SELECT * FROM {$tableExpr} AS {$aliasQuoted} WHERE {$uidQuoted} = " . ':'.Storage::UID;
+            $stmt = null;
+            $row = false;
+            $exception = null;
+
+            try {
+                $stmt = $this->prepareStatement($sql, Event::DocumentRead);
+                $stmt->bindValue(':'.Storage::UID, $id, PDO::PARAM_STR);
+                $this->execute($stmt);
+                /** @var array<string, mixed>|false $row */
+                $row = $stmt->fetch();
+            } catch (PDOException $e) {
+                $exception = $e;
+            } finally {
+                if ($stmt !== null) {
+                    try {
+                        $stmt->closeCursor();
+                    } catch (PDOException $e) {
+                        $exception ??= $e;
+                    }
+                }
+            }
 
-        $forUpdate = $forUpdate ? 'FOR UPDATE' : '';
+            if ($exception !== null) {
+                throw $this->processException($exception);
+            }
 
-        $alias = Query::DEFAULT_ALIAS;
+            if (! is_array($row) || empty($row)) {
+                return new Document([]);
+            }
 
-        $sql = "
-		    SELECT {$this->getAttributeProjection($selections, $alias)}
-            FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-            WHERE {$this->quote($alias)}.{$this->quote('_uid')} = :_uid 
-            {$this->getTenantQuery($collection, $alias)}
-		";
+            $this->remapRow($row);
 
-        if ($this->getSupportForUpdateLock()) {
-            $sql .= " {$forUpdate}";
+            return Document::fromRow($row);
         }
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_READ, $sql);
+        if ($this->queriesHaveJoins($queries)) {
+            if ($forUpdate) {
+                throw new QueryException('Cannot lock a document for update when join queries are present');
+            }
 
-        $stmt = null;
-        $document = [];
-        $exception = null;
+            $roles = $this->authorization->getRoles();
+            $queries = \array_map(static fn ($query) => clone $query, $queries);
+            $joinTablePrefixes = $this->remapJoinQueries($queries);
+            $queries = $this->rewriteFullOuterJoins($queries, Method::LeftJoin);
 
-        try {
-            $stmt = $this->getPDO()->prepare($sql);
+            $hasPreservingOuterJoin = false;
+            foreach ($queries as $query) {
+                $method = $query->getMethod();
+                if ($method === Method::RightJoin || $method === Method::FullOuterJoin) {
+                    $hasPreservingOuterJoin = true;
+                    break;
+                }
+            }
 
-            $stmt->bindValue(':_uid', $id);
+            if ($this->needsFullOuterJoinEmulation($this->createBuilder(), $queries)) {
+                $uid = $alias.'.'.Storage::UID;
+                $leftQueries = $this->rewriteFullOuterJoins($queries, Method::LeftJoin);
+                $leftQueries[] = BaseQuery::equal($uid, [$id]);
+                $rightQueries = $this->rewriteFullOuterJoins($queries, Method::RightJoin);
+                $rightQueries[] = BaseQuery::isNull($uid);
+                $rightQueries[] = BaseQuery::equal($uid, [$id]);
+
+                $left = $this->newBuilder($name, $alias, false);
+                $this->configureFindBuilder(
+                    $left,
+                    $collectionDoc,
+                    $leftQueries,
+                    $joinTablePrefixes,
+                    false,
+                    false,
+                    [],
+                    $name,
+                    $alias,
+                    $roles,
+                    PermissionType::Read,
+                    false,
+                );
+
+                $right = $this->newBuilder($name, $alias, true);
+                $this->configureFindBuilder(
+                    $right,
+                    $collectionDoc,
+                    $rightQueries,
+                    $joinTablePrefixes,
+                    false,
+                    false,
+                    [],
+                    $name,
+                    $alias,
+                    $roles,
+                    PermissionType::Read,
+                    true,
+                );
+
+                $left->unionAll($right);
+                $this->applyFindPage($left, [], [], 1, null, afterUnion: true);
+                $builder = $left;
+            } else {
+                $builder = $this->newBuilder($name, $alias, $hasPreservingOuterJoin);
+                $this->configureFindBuilder(
+                    $builder,
+                    $collectionDoc,
+                    $queries,
+                    $joinTablePrefixes,
+                    false,
+                    false,
+                    [],
+                    $name,
+                    $alias,
+                    $roles,
+                    PermissionType::Read,
+                    $hasPreservingOuterJoin,
+                );
+                $builder->filter([BaseQuery::equal($alias.'.'.Storage::UID, [$id])]);
+                $builder->limit(1);
+            }
+        } else {
+            $builder = $this->newBuilder($name, $alias);
 
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->getTenant());
+            if (! empty($selections) && ! \in_array('*', $selections)) {
+                $builder->select($this->mapSelectionsToColumns($selections, joinAliases: []));
             }
 
-            $this->execute($stmt);
-            $document = $stmt->fetchAll();
-        } catch (PDOException $e) {
-            $exception = $e;
-        } finally {
-            if ($stmt !== null) {
-                try {
-                    $stmt->closeCursor();
-                } catch (PDOException $e) {
-                    $exception ??= $e;
-                }
+            $builder->filter([BaseQuery::equal(Storage::UID, [$id])]);
+
+            if ($forUpdate && $this->supports(Capability::UpdateLock)) {
+                $builder->forUpdate();
             }
         }
 
-        if ($exception !== null) {
-            throw $this->processException($exception);
-        }
+        $rows = $this->executeSelect($builder, Event::DocumentRead);
 
-        if (empty($document)) {
+        if (empty($rows)) {
             return new Document([]);
         }
 
-        $document = $document[0];
-
-        if (\array_key_exists('_id', $document)) {
-            $document['$sequence'] = $document['_id'];
-            unset($document['_id']);
-        }
-        if (\array_key_exists('_uid', $document)) {
-            $document['$id'] = $document['_uid'];
-            unset($document['_uid']);
-        }
-        if (\array_key_exists('_tenant', $document)) {
-            $document['$tenant'] = $document['_tenant'];
-            unset($document['_tenant']);
-        }
-        if (\array_key_exists('_createdAt', $document)) {
-            $document['$createdAt'] = $document['_createdAt'];
-            unset($document['_createdAt']);
-        }
-        if (\array_key_exists('_updatedAt', $document)) {
-            $document['$updatedAt'] = $document['_updatedAt'];
-            unset($document['_updatedAt']);
-        }
-        if (\array_key_exists('_deletedAt', $document)) {
-            $document['$deletedAt'] = $document['_deletedAt'];
-            unset($document['_deletedAt']);
-        }
-        if (\array_key_exists('_permissions', $document)) {
-            $document['$permissions'] = json_decode($document['_permissions'] ?? '[]', true);
-            unset($document['_permissions']);
-        }
+        /** @var array<string, mixed> $document */
+        $document = $rows[0];
 
-        return new Document($document);
-    }
+        $this->remapRow($document);
 
-    /**
-     * Helper method to extract spatial type attributes from collection attributes
-     *
-     * @param Document $collection
-     * @return array<int,string>
-     */
-    protected function getSpatialAttributes(Document $collection): array
-    {
-        $collectionAttributes = $collection->getAttribute('attributes', []);
-        $spatialAttributes = [];
-        foreach ($collectionAttributes as $attr) {
-            if ($attr instanceof Document) {
-                $attributeType = $attr->getAttribute('type');
-                if (in_array($attributeType, Database::SPATIAL_TYPES)) {
-                    $spatialAttributes[] = $attr->getId();
-                }
-            }
-        }
-        return $spatialAttributes;
+        return Document::fromRow($document);
     }
 
     /**
-     * Update documents
-     *
-     * Updates all documents which match the given query.
-     *
-     * @param Document $collection
-     * @param Document $updates
-     * @param array<Document> $documents
+     * Create Documents in batches
      *
-     * @return int
+     * @param  array<Document>  $documents
+     * @return array<Document>
      *
-     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws Throwable
      */
-    public function updateDocuments(Document $collection, Document $updates, array $documents): int
+    public function createDocuments(Document $collection, array $documents): array
     {
         if (empty($documents)) {
-            return 0;
+            return $documents;
         }
+
+        $this->syncWriteHooks();
+
         $spatialAttributes = $this->getSpatialAttributes($collection);
         $collection = $collection->getId();
+        try {
+            $name = $this->filter($collection);
 
-        $attributes = $updates->getAttributes();
+            $attributeKeySet = [];
+            foreach (Database::INTERNAL_ATTRIBUTE_KEYS as $k) {
+                $attributeKeySet[$k] = true;
+            }
 
-        if (!empty($updates->getUpdatedAt())) {
-            $attributes['_updatedAt'] = $updates->getUpdatedAt();
-        }
+            $hasSequence = null;
+            foreach ($documents as $document) {
+                foreach ($document->getAttributes() as $key => $value) {
+                    $attributeKeySet[$key] = true;
+                }
 
-        if (!empty($updates->getCreatedAt())) {
-            $attributes['_createdAt'] = $updates->getCreatedAt();
-        }
+                if ($hasSequence === null) {
+                    $hasSequence = ! empty($document->getSequence());
+                } elseif ($hasSequence == empty($document->getSequence())) {
+                    throw new DatabaseException('All documents must have an sequence if one is set');
+                }
+            }
 
-        if ($updates->offsetExists('$permissions')) {
-            $attributes['_permissions'] = json_encode($updates->getPermissions());
-        }
+            $attributeKeys = \array_keys($attributeKeySet);
 
-        if (empty($attributes)) {
-            return 0;
-        }
+            if ($hasSequence) {
+                $attributeKeys[] = Storage::SEQUENCE;
+            }
 
-        $keyIndex = 0;
-        $operatorBinds = [];
-        $columns = '';
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
 
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
+            // Hoist per-row guards out of the document loop so a 1k-doc batch
+            // doesn't reallocate the spatial map and re-resolve the capability
+            // 1k times. Also pick up WKT / geometry-array values the collection
+            // metadata scan missed (stale process-local cache, typed Attribute
+            // objects, or encode() already converting defaults to WKT).
+            $spatialAttributes = $this->expandSpatialAttributes($spatialAttributes, $documents);
+            $spatialMap = \array_fill_keys($spatialAttributes, true);
 
-            // Check if this is an operator, spatial attribute, or regular attribute
-            if (Operator::isOperator($value)) {
-                $columns .= $this->getOperatorSQL($column, $value, $operatorBinds);
-            } elseif (\in_array($attribute, $spatialAttributes)) {
-                $columns .= "{$this->quote($column)} = " . $this->getSpatialGeomFromText(":key_{$keyIndex}");
-                $keyIndex++;
-            } else {
-                $columns .= "{$this->quote($column)} = :key_{$keyIndex}";
-                $keyIndex++;
+            foreach ($spatialAttributes as $spatialCol) {
+                $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
             }
 
-            if ($attribute !== \array_key_last($attributes)) {
-                $columns .= ',';
+            $intBools = $this->supports(Capability::IntegerBooleans);
+
+            foreach ($documents as $document) {
+                $row = $this->buildDocumentRow($document, $attributeKeys, $spatialMap, $intBools);
+                $row = $this->decorateRow($row, $this->documentMetadata($document));
+                $builder->set($row);
+            }
+
+            if ($this->skipDuplicates) {
+                if (! $builder instanceof InsertOrIgnoreFeature) {
+                    throw new DatabaseException('Insert-or-ignore is not supported on this dialect');
+                }
+
+                $result = $builder->insertOrIgnore();
+            } else {
+                $result = $builder->insert();
             }
+            $stmt = $this->executeResult($result, Event::DocumentsCreate);
+            $this->execute($stmt);
+
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, $documents, $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        // Remove trailing comma if present
-        $columns = \rtrim($columns, ',');
+        return $documents;
+    }
 
-        if (empty($columns)) {
+    /**
+     * Update documents
+     *
+     * Updates all documents which match the given query.
+     *
+     * @param  array<Document>  $documents
+     *
+     * @throws DatabaseException
+     */
+    public function updateDocuments(Document $collection, Document $updates, array $documents): int
+    {
+        if (empty($documents)) {
             return 0;
         }
 
-        $name = $this->filter($collection);
-        $sequences = \array_map(fn ($document) => $document->getSequence(), $documents);
+        $this->syncWriteHooks();
+
+        $spatialAttributes = $this->getSpatialAttributes($collection);
+        $collection = $collection->getId();
+
+        $attributes = $updates->getAttributes();
 
-        $sql = "
-            UPDATE {$this->getSQLTable($name)}
-            SET {$columns}
-            WHERE _id IN (" . \implode(', ', \array_map(fn ($index) => ":_id_{$index}", \array_keys($sequences))) . ")
-            {$this->getTenantQuery($collection)}
-        ";
+        if (! empty($updates->getUpdatedAt())) {
+            $attributes[Storage::UPDATED_AT] = $updates->getUpdatedAt();
+        }
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENTS_UPDATE, $sql);
-        $stmt = $this->getPDO()->prepare($sql);
+        if (! empty($updates->getCreatedAt())) {
+            $attributes[Storage::CREATED_AT] = $updates->getCreatedAt();
+        }
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+        if ($updates->offsetExists(Document::PERMISSIONS)) {
+            $attributes[Storage::PERMISSIONS] = json_encode($updates->getPermissions());
         }
 
-        foreach ($sequences as $id => $value) {
-            $stmt->bindValue(":_id_{$id}", $value);
+        if (empty($attributes)) {
+            return 0;
         }
 
-        $keyIndex = 0;
-        foreach ($attributes as $attributeName => $value) {
-            // Skip operators as they don't need value binding
+        $name = $this->filter($collection);
+
+        // Build the UPDATE using the query builder
+        $builder = $this->newBuilder($name);
+
+        // Single pass over update attributes, bucketing into regular / spatial /
+        // operator and applying JSON / boolean conversions inline. Hoisted
+        // guards keep the hot path branch-light.
+        $spatialMap = \array_fill_keys($spatialAttributes, true);
+        $intBools = $this->supports(Capability::IntegerBooleans);
+
+        $regularRow = [];
+        $spatialRows = [];
+        $operators = [];
+
+        foreach ($attributes as $attribute => $value) {
             if (Operator::isOperator($value)) {
+                $operators[$attribute] = $value;
+
                 continue;
             }
 
-            // Convert spatial arrays to WKT, json_encode non-spatial arrays
-            if (\in_array($attributeName, $spatialAttributes, true)) {
-                if (\is_array($value)) {
-                    $value = $this->convertArrayToWKT($value);
-                }
-            } elseif (\is_array($value)) {
-                $value = \json_encode($value);
+            if (isset($spatialMap[$attribute]) || $this->isSpatialWkt($value)) {
+                $spatialRows[$this->filter($attribute)] = $this->encodeSpatialWriteValue($value);
+
+                continue;
             }
 
-            $bindKey = 'key_' . $keyIndex;
-            if ($this->getSupportForIntegerBooleans()) {
-                $value = (\is_bool($value)) ? (int)$value : $value;
+            $column = $this->filter($attribute);
+
+            if (\is_array($value)) {
+                $value = \json_encode($value);
+            }
+            if ($intBools && \is_bool($value)) {
+                $value = (int) $value;
             }
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $keyIndex++;
-        }
 
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
+            $regularRow[$column] = $value;
         }
 
-        try {
-            $stmt->execute();
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        if (! empty($regularRow)) {
+            $builder->set($regularRow);
         }
 
-        $affected = $stmt->rowCount();
+        // Spatial attributes use setRaw with ST_GeomFromText(?)
+        foreach ($spatialRows as $column => $value) {
+            $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$value]);
+        }
 
-        // Permissions logic
-        if ($updates->offsetExists('$permissions')) {
-            $removeQueries = [];
-            $removeBindValues = [];
+        // Operator attributes use setRaw with converted expressions
+        foreach ($operators as $attribute => $operator) {
+            $column = $this->filter($attribute);
+            /** @var Operator $operator */
+            $opResult = $this->getOperatorBuilderExpression($column, $operator);
+            $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
+        }
 
-            $addQuery = '';
-            $addBindValues = [];
+        $builder->setRaw(Storage::VERSION, $this->quote(Storage::VERSION) . ' + 1', []);
 
-            foreach ($documents as $index => $document) {
-                if ($document->getAttribute('$skipPermissionsUpdate', false)) {
-                    continue;
-                }
+        // WHERE _id IN (sequence values)
+        $sequences = \array_map(fn ($document) => $document->getSequence(), $documents);
+        $builder->filter([BaseQuery::equal(Storage::SEQUENCE, \array_values($sequences))]);
 
-                $sql = "
-                    SELECT _type, _permission
-                    FROM {$this->getSQLTable($name . '_perms')}
-                    WHERE _document = :_uid
-                    {$this->getTenantQuery($collection)}
-                ";
+        $result = $builder->update();
+        $stmt = $this->executeResult($result, Event::DocumentsUpdate);
 
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_READ, $sql);
+        try {
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
 
-                $permissionsStmt = $this->getPDO()->prepare($sql);
-                $permissionsStmt->bindValue(':_uid', $document->getId());
+        $affected = $stmt->rowCount();
 
-                if ($this->sharedTables) {
-                    $permissionsStmt->bindValue(':_tenant', $this->tenant);
-                }
+        $ctx = $this->buildWriteContext($name);
+        $this->runWriteHooks(fn ($hook) => $hook->afterDocumentBatchUpdate($name, $updates, $documents, $ctx));
 
-                $permissionsStmt->execute();
-                $permissions = $permissionsStmt->fetchAll();
-                $permissionsStmt->closeCursor();
+        return $affected;
+    }
 
-                $initial = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $initial[$type] = [];
-                }
+    /**
+     * @param  array<Change>  $changes
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     */
+    public function upsertDocuments(
+        Document $collection,
+        string $attribute,
+        array $changes
+    ): array {
+        if (empty($changes)) {
+            return $changes;
+        }
+        try {
+            $spatialAttributes = $this->getSpatialAttributes($collection);
 
-                $permissions = \array_reduce($permissions, function (array $carry, array $item) {
-                    $carry[$item['_type']][] = $item['_permission'];
-                    return $carry;
-                }, $initial);
+            /** @var array<string, mixed> $attributeDefaults */
+            $attributeDefaults = [];
+            /** @var array<mixed> $collAttrs */
+            $collAttrs = $collection->getAttribute('attributes', []);
+            foreach ($collAttrs as $attr) {
+                /** @var array<string, mixed> $attr */
+                $attrIdRaw = $attr[Document::ID] ?? '';
+                $attrId = \is_scalar($attrIdRaw) ? (string) $attrIdRaw : '';
+                $attributeDefaults[$attrId] = $attr['default'] ?? null;
+            }
 
-                // Get removed Permissions
-                $removals = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = array_diff($permissions[$type], $updates->getPermissionsByType($type));
-                    if (!empty($diff)) {
-                        $removals[$type] = $diff;
-                    }
-                }
+            $collection = $collection->getId();
+            $name = $this->filter($collection);
 
-                // Build inner query to remove permissions
-                if (!empty($removals)) {
-                    foreach ($removals as $type => $permissionsToRemove) {
-                        $bindKey = '_uid_' . $index;
-                        $removeBindKeys[] = ':_uid_' . $index;
-                        $removeBindValues[$bindKey] = $document->getId();
-
-                        $removeQueries[] = "(
-                            _document = :_uid_{$index}
-                            {$this->getTenantQuery($collection)}
-                            AND _type = '{$type}'
-                            AND _permission IN (" . \implode(', ', \array_map(function (string $i) use ($permissionsToRemove, $index, $type, &$removeBindKeys, &$removeBindValues) {
-                            $bindKey = 'remove_' . $type . '_' . $index . '_' . $i;
-                            $removeBindKeys[] = ':' . $bindKey;
-                            $removeBindValues[$bindKey] = $permissionsToRemove[$i];
-
-                            return ':' . $bindKey;
-                        }, \array_keys($permissionsToRemove))) .
-                            ")
-                        )";
-                    }
-                }
+            $hasOperators = false;
+            $firstChange = $changes[0];
+            $firstDoc = $firstChange->getNew();
+            $firstExtracted = Operator::extractOperators($firstDoc->getAttributes());
 
-                // Get added Permissions
-                $additions = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = \array_diff($updates->getPermissionsByType($type), $permissions[$type]);
-                    if (!empty($diff)) {
-                        $additions[$type] = $diff;
+            if (! empty($firstExtracted['operators'])) {
+                $hasOperators = true;
+            } else {
+                foreach ($changes as $change) {
+                    $doc = $change->getNew();
+                    $extracted = Operator::extractOperators($doc->getAttributes());
+                    if (! empty($extracted['operators'])) {
+                        $hasOperators = true;
+                        break;
                     }
                 }
+            }
 
-                // Build inner query to add permissions
-                if (!empty($additions)) {
-                    foreach ($additions as $type => $permissionsToAdd) {
-                        foreach ($permissionsToAdd as $i => $permission) {
-                            $bindKey = '_uid_' . $index;
-                            $addBindValues[$bindKey] = $document->getId();
-
-                            $bindKey = 'add_' . $type . '_' . $index . '_' . $i;
-                            $addBindValues[$bindKey] = $permission;
-
-                            $addQuery .= "(:_uid_{$index}, '{$type}', :{$bindKey}";
+            if (! $hasOperators) {
+                $this->executeUpsertBatch($name, $changes, $spatialAttributes, $attribute, [], $attributeDefaults, false);
+            } else {
+                $groups = [];
 
-                            if ($this->sharedTables) {
-                                $addQuery .= ", :_tenant)";
-                            } else {
-                                $addQuery .= ")";
-                            }
+                foreach ($changes as $change) {
+                    $document = $change->getNew();
+                    $extracted = Operator::extractOperators($document->getAttributes());
+                    $operators = $extracted['operators'];
 
-                            if ($i !== \array_key_last($permissionsToAdd) || $type !== \array_key_last($additions)) {
-                                $addQuery .= ', ';
-                            }
+                    if (empty($operators)) {
+                        $signature = 'no_ops';
+                    } else {
+                        $parts = [];
+                        foreach ($operators as $attr => $op) {
+                            $parts[] = $attr.':'.$op->getMethod()->value.':'.json_encode($op->getValues());
                         }
+                        sort($parts);
+                        $signature = implode('|', $parts);
                     }
-                    if ($index !== \array_key_last($documents)) {
-                        $addQuery .= ', ';
-                    }
-                }
-            }
-
-            if (!empty($removeQueries)) {
-                $removeQuery = \implode(' OR ', $removeQueries);
 
-                $stmtRemovePermissions = $this->getPDO()->prepare("
-                    DELETE
-                    FROM {$this->getSQLTable($name . '_perms')}
-                    WHERE ({$removeQuery})
-                ");
+                    if (! isset($groups[$signature])) {
+                        $groups[$signature] = [
+                            'documents' => [],
+                            'operators' => $operators,
+                        ];
+                    }
 
-                foreach ($removeBindValues as $key => $value) {
-                    $stmtRemovePermissions->bindValue($key, $value, $this->getPDOType($value));
+                    $groups[$signature]['documents'][] = $change;
                 }
 
-                if ($this->sharedTables) {
-                    $stmtRemovePermissions->bindValue(':_tenant', $this->tenant);
+                foreach ($groups as $group) {
+                    $this->executeUpsertBatch($name, $group['documents'], $spatialAttributes, '', $group['operators'], $attributeDefaults, true);
                 }
-                $stmtRemovePermissions->execute();
             }
 
-            if (!empty($addQuery)) {
-                $sqlAddPermissions = "
-                    INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission
-                ";
-
-                if ($this->sharedTables) {
-                    $sqlAddPermissions .= ', _tenant)';
-                } else {
-                    $sqlAddPermissions .= ')';
-                }
-
-                $sqlAddPermissions .=  " VALUES {$addQuery}";
-
-                $stmtAddPermissions = $this->getPDO()->prepare($sqlAddPermissions);
-
-                foreach ($addBindValues as $key => $value) {
-                    $stmtAddPermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
-
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(':_tenant', $this->tenant);
-                }
-
-                $stmtAddPermissions->execute();
-            }
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpsert($name, $changes, $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        return $affected;
+        return \array_map(fn ($change) => $change->getNew(), $changes);
     }
 
-
     /**
      * Delete Documents
      *
-     * @param string $collection
-     * @param array<string> $sequences
-     * @param array<string> $permissionIds
+     * @param  array<string>  $sequences
+     * @param  array<string>  $permissionIds
      *
-     * @return int
      * @throws DatabaseException
      */
     public function deleteDocuments(string $collection, array $sequences, array $permissionIds): int
@@ -794,55 +1105,24 @@ public function deleteDocuments(string $collection, array $sequences, array $per
             return 0;
         }
 
+        $this->syncWriteHooks();
+
         try {
             $name = $this->filter($collection);
 
-            $sql = "
-            DELETE FROM {$this->getSQLTable($name)} 
-            WHERE _id IN (" . \implode(', ', \array_map(fn ($index) => ":_id_{$index}", \array_keys($sequences))) . ")
-            {$this->getTenantQuery($collection)}
-            ";
-
-            $sql = $this->trigger(Database::EVENT_DOCUMENTS_DELETE, $sql);
-
-            $stmt = $this->getPDO()->prepare($sql);
+            // Delete documents
+            $builder = $this->newBuilder($name);
+            $builder->filter([BaseQuery::equal(Storage::SEQUENCE, \array_values($sequences))]);
+            $result = $builder->delete();
+            $stmt = $this->executeResult($result, Event::DocumentsDelete);
 
-            foreach ($sequences as $id => $value) {
-                $stmt->bindValue(":_id_{$id}", $value);
-            }
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
-            }
-
-            if (!$stmt->execute()) {
+            if (! $this->execute($stmt)) {
                 throw new DatabaseException('Failed to delete documents');
             }
 
-            if (!empty($permissionIds)) {
-                $sql = "
-                DELETE FROM {$this->getSQLTable($name . '_perms')} 
-                WHERE _document IN (" . \implode(', ', \array_map(fn ($index) => ":_id_{$index}", \array_keys($permissionIds))) . ")
-                {$this->getTenantQuery($collection)}
-                ";
-
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
-
-                $stmtPermissions = $this->getPDO()->prepare($sql);
-
-                foreach ($permissionIds as $id => $value) {
-                    $stmtPermissions->bindValue(":_id_{$id}", $value);
-                }
-
-                if ($this->sharedTables) {
-                    $stmtPermissions->bindValue(':_tenant', $this->tenant);
-                }
-
-                if (!$stmtPermissions->execute()) {
-                    throw new DatabaseException('Failed to delete permissions');
-                }
-            }
-        } catch (\Throwable $e) {
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentDelete($name, \array_values($permissionIds), $ctx));
+        } catch (Throwable $e) {
             throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
         }
 
@@ -852,29 +1132,18 @@ public function deleteDocuments(string $collection, array $sequences, array $per
     /**
      * Assign internal IDs for the given documents
      *
-     * @param string $collection
-     * @param array<Document> $documents
+     * @param  array<Document>  $documents
      * @return array<Document>
+     *
      * @throws DatabaseException
      */
     public function getSequences(string $collection, array $documents): array
     {
         $documentIds = [];
-        $keys = [];
-        $binds = [];
 
-        foreach ($documents as $i => $document) {
+        foreach ($documents as $document) {
             if (empty($document->getSequence())) {
                 $documentIds[] = $document->getId();
-
-                $key = ":uid_{$i}";
-
-                $binds[$key] = $document->getId();
-                $keys[] = $key;
-
-                if ($this->sharedTables) {
-                    $binds[':_tenant_'.$i] = $document->getTenant();
-                }
             }
         }
 
@@ -882,268 +1151,926 @@ public function getSequences(string $collection, array $documents): array
             return $documents;
         }
 
-        $placeholders = implode(',', array_values($keys));
-
-        $sql = "
-            SELECT _uid, _id
-            FROM {$this->getSQLTable($collection)}
-            WHERE {$this->quote('_uid')} IN ({$placeholders})
-            {$this->getTenantQuery($collection, tenantCount: \count($documentIds))}
-            ";
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        foreach ($binds as $key => $value) {
-            $stmt->bindValue($key, $value);
-        }
+        $builder = $this->newBuilder($collection);
+        $builder->select([Storage::UID, Storage::SEQUENCE]);
+        $builder->filter([BaseQuery::equal(Storage::UID, $documentIds)]);
 
-        $stmt->execute();
-        $sequences = $stmt->fetchAll(\PDO::FETCH_KEY_PAIR); // Fetch as [documentId => sequence]
+        $result = $builder->build();
+        $stmt = $this->executeResult($result, Event::DocumentRead);
+        $this->execute($stmt);
+        /** @var array<string, mixed> $sequences */
+        $sequences = $stmt->fetchAll(PDO::FETCH_KEY_PAIR); // Fetch as [documentId => sequence]
         $stmt->closeCursor();
 
         foreach ($documents as $document) {
             if (isset($sequences[$document->getId()])) {
-                $document['$sequence'] = $sequences[$document->getId()];
+                $document[Document::SEQUENCE] = $sequences[$document->getId()];
             }
         }
 
         return $documents;
     }
 
-    /**
-     * Get max STRING limit
-     *
-     * @return int
-     */
-    public function getLimitForString(): int
-    {
-        return 4294967295;
-    }
+    public function increaseDocumentAttribute(
+        string $collection,
+        string $id,
+        string $attribute,
+        int|float|string $value,
+        string $updatedAt,
+        int|float|string|null $min = null,
+        int|float|string|null $max = null
+    ): bool {
+        $name = $this->filter($collection);
+        $attribute = $this->filter($attribute);
 
-    /**
-     * Get max INT limit
-     *
-     * @return int
-     */
-    public function getLimitForInt(): int
-    {
-        return 4294967295;
+        $builder = $this->newBuilder($name);
+        $builder->setRaw($attribute, $this->quote($attribute).' + ?', [$value]);
+        $builder->set([Storage::UPDATED_AT => $updatedAt]);
+
+        $filters = [BaseQuery::equal(Storage::UID, [$id])];
+        if ($max !== null) {
+            $filters[] = BaseQuery::lessThanEqual($attribute, $max);
+        }
+        if ($min !== null) {
+            $filters[] = BaseQuery::greaterThanEqual($attribute, $min);
+        }
+        $builder->filter($filters);
+
+        $result = $builder->update();
+        $event = $value < 0 ? Event::DocumentDecrease : Event::DocumentIncrease;
+        $stmt = $this->executeResult($result, $event);
+
+        try {
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        return true;
     }
 
-    /**
-     * Get max BIGINT limit
-     *
-     * @return int
-     */
-    public function getLimitForBigInt(): int
+    public function deleteDocument(string $collection, string $id): bool
     {
-        return Database::MAX_BIG_INT;
+        try {
+            $this->syncWriteHooks();
+
+            $name = $this->filter($collection);
+
+            $builder = $this->newBuilder($name);
+            $builder->filter([BaseQuery::equal(Storage::UID, [$id])]);
+            $result = $builder->delete();
+            $stmt = $this->executeResult($result, Event::DocumentDelete);
+
+            if (! $this->execute($stmt)) {
+                throw new DatabaseException('Failed to delete document');
+            }
+
+            $deleted = $stmt->rowCount();
+
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentDelete($name, [$id], $ctx));
+        } catch (\Throwable $e) {
+            throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+        }
+
+        return $deleted > 0;
     }
 
     /**
-     * Get maximum column limit.
-     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
-     * Can be inherited by MySQL since we utilize the InnoDB engine
+     * Find Documents
      *
-     * @return int
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     * @throws TimeoutException
+     * @throws Exception
      */
-    public function getLimitForAttributes(): int
+    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], CursorDirection $cursorDirection = CursorDirection::After, PermissionType $forPermission = PermissionType::Read): array
     {
-        return 1017;
-    }
+        $collectionDoc = $collection;
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
 
-    /**
-     * Get maximum index limit.
-     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
-     *
-     * @return int
-     */
-    public function getLimitForIndexes(): int
-    {
-        return 64;
-    }
+        // Fast path: trivial SELECT * with default ORDER BY _id and LIMIT/OFFSET.
+        // Triggered when there are no filters/joins/aggregations/cursor queries,
+        // a single default order attribute, ascending, no shared tenant, and no
+        // active permission filter. This is the common "list documents" case
+        // and bypasses Builder allocation entirely.
+        if (
+            empty($queries)
+            && empty($cursor)
+            && ! $this->authorization->getStatus()
+            && ! ($this->sharedTables && $this->tenant !== null)
+            && (count($orderAttributes) === 1)
+            && ($orderAttributes[0] === Document::SEQUENCE)
+            && (empty($orderTypes) || ($orderTypes[0] ?? OrderDirection::Asc) === OrderDirection::Asc)
+            && $cursorDirection === CursorDirection::After
+        ) {
+            $internalOrder = $this->quote($this->getInternalKeyForAttribute(Document::SEQUENCE));
+            $tableExpr = $this->getSQLTable($name);
+            $aliasQuoted = $this->quote($alias);
+            $limitClause = $limit !== null ? " LIMIT {$limit}" : '';
+            $offsetClause = $offset !== null && $offset > 0 ? " OFFSET {$offset}" : ($limit !== null ? ' OFFSET 0' : '');
+
+            $sql = "SELECT * FROM {$tableExpr} AS {$aliasQuoted} ORDER BY {$internalOrder} ASC{$limitClause}{$offsetClause}";
+            $stmt = null;
+            $rows = [];
+            $exception = null;
+
+            try {
+                $stmt = $this->prepareStatement($sql, Event::DocumentFind);
+                $this->execute($stmt);
+                /** @var array<int, array<string, mixed>> $rows */
+                $rows = $stmt->fetchAll();
+            } catch (PDOException $e) {
+                $exception = $e;
+            } finally {
+                if ($stmt !== null) {
+                    try {
+                        $stmt->closeCursor();
+                    } catch (PDOException $e) {
+                        $exception ??= $e;
+                    }
+                }
+            }
 
-    /**
-     * Is schemas supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemas(): bool
-    {
-        return true;
+            if ($exception !== null) {
+                throw $this->processException($exception);
+            }
+
+            $documents = [];
+            foreach ($rows as $row) {
+                $this->remapRow($row);
+                $documents[] = Document::fromRow($row);
+            }
+
+            return $documents;
+        }
+
+        // Single pass partitioning: pull vector queries out for ORDER BY and
+        // detect aggregation/join shape in the same walk. Each Method::value
+        // is checked once per query rather than three times. Search queries
+        // are picked up here too so we don't need a second pass via
+        // `extractSearchQueries` later in this method.
+        // Defer the defensive `clone` until we know the query path will mutate
+        // the Query objects (joins or aggregations-with-joins). The vast
+        // majority of finds take neither path and don't need a per-query
+        // clone allocation.
+        $vectorQueries = [];
+        $otherQueries = [];
+        $adapterFilterQueries = [];
+        $searchQueries = [];
+        $hasAggregation = false;
+        $hasJoins = false;
+        $hasDistinct = false;
+
+        foreach ($queries as $query) {
+            $method = $query->getMethod();
+
+            if ($method->isVector()) {
+                $vectorQueries[] = $query;
+
+                continue;
+            }
+
+            if ($this->isAdapterFilterQuery($query)) {
+                $adapterFilterQueries[] = $query;
+
+                continue;
+            }
+
+            $otherQueries[] = $query;
+
+            if ($method === Method::Search) {
+                $searchQueries[] = $query;
+            }
+
+            if ($method->isAggregate() || $method === Method::GroupBy) {
+                $hasAggregation = true;
+            }
+            if ($method->isJoin()) {
+                $hasJoins = true;
+            }
+            if ($method === Method::Distinct) {
+                $hasDistinct = true;
+            }
+        }
+
+        $queries = $otherQueries;
+
+        if ($hasJoins) {
+            $queries = \array_map(static fn ($query) => clone $query, $queries);
+        }
+
+        $joinTablePrefixes = [];
+        if ($hasJoins) {
+            $joinTablePrefixes = $this->remapJoinQueries($queries);
+        }
+
+        $hasPreservingOuterJoin = false;
+        if ($hasJoins) {
+            foreach ($queries as $query) {
+                $method = $query->getMethod();
+                if ($method === Method::RightJoin || $method === Method::FullOuterJoin) {
+                    $hasPreservingOuterJoin = true;
+                    break;
+                }
+            }
+        }
+
+        $joinAliases = \array_column($joinTablePrefixes, 'alias');
+        $internalKeyCache = [];
+        $resolveInternalKey = function (string $attribute) use (&$internalKeyCache, $joinAliases): string {
+            return $internalKeyCache[$attribute]
+                ??= $this->qualifyOrderAttribute($attribute, $joinAliases);
+        };
+
+        if ($this->needsFullOuterJoinEmulation($this->createBuilder(), $queries)) {
+            $leftQueries = $this->rewriteFullOuterJoins($queries, Method::LeftJoin);
+            $rightQueries = $this->rewriteFullOuterJoins($queries, Method::RightJoin);
+            $rightQueries[] = BaseQuery::isNull($alias.'.'.Storage::UID);
+
+            $left = $this->newBuilder($name, $alias, false);
+            $leftProjected = $this->configureFindBuilder(
+                $left,
+                $collectionDoc,
+                $leftQueries,
+                $joinTablePrefixes,
+                $hasAggregation,
+                $hasDistinct,
+                $adapterFilterQueries,
+                $name,
+                $alias,
+                $roles,
+                $forPermission,
+                false,
+            );
+            $this->applyFullOuterJoinOrderProjection(
+                $left,
+                $alias,
+                $orderAttributes,
+                $orderTypes,
+                $leftProjected,
+                $joinTablePrefixes,
+            );
+            $this->applyFindCursor(
+                $left,
+                $orderAttributes,
+                $orderTypes,
+                $cursor,
+                $cursorDirection,
+                $resolveInternalKey,
+            );
+
+            $right = $this->newBuilder($name, $alias, true);
+            $rightProjected = $this->configureFindBuilder(
+                $right,
+                $collectionDoc,
+                $rightQueries,
+                $joinTablePrefixes,
+                $hasAggregation,
+                $hasDistinct,
+                $adapterFilterQueries,
+                $name,
+                $alias,
+                $roles,
+                $forPermission,
+                true,
+            );
+            $this->applyFullOuterJoinOrderProjection(
+                $right,
+                $alias,
+                $orderAttributes,
+                $orderTypes,
+                $rightProjected,
+                $joinTablePrefixes,
+            );
+            $this->applyFindCursor(
+                $right,
+                $orderAttributes,
+                $orderTypes,
+                $cursor,
+                $cursorDirection,
+                $resolveInternalKey,
+            );
+
+            $left->unionAll($right);
+            $this->applyFindPage($left, $orderAttributes, $orderTypes, $limit, $offset, $cursorDirection, afterUnion: true);
+            $results = $this->executeSelect($left, Event::DocumentFind);
+        } else {
+            $builder = $this->newBuilder($name, $alias, $hasPreservingOuterJoin);
+            $hasSelectionProjection = $this->configureFindBuilder(
+                $builder,
+                $collectionDoc,
+                $queries,
+                $joinTablePrefixes,
+                $hasAggregation,
+                $hasDistinct,
+                $adapterFilterQueries,
+                $name,
+                $alias,
+                $roles,
+                $forPermission,
+                $hasPreservingOuterJoin,
+            );
+
+            $vectorDistance = null;
+            $vectorQuery = $vectorQueries[0] ?? null;
+            if ($vectorQuery !== null) {
+                $vectorDistance = $this->getVectorOrderRaw($vectorQuery, $alias);
+            }
+
+            if ($vectorDistance !== null && $vectorQuery !== null) {
+                $vectorAttribute = $this->quote($this->filter($vectorQuery->getAttribute()));
+                $builder->whereRaw($this->quote($alias).".{$vectorAttribute} IS NOT NULL");
+            }
+
+            // Cursor pagination - build nested Query objects for complex multi-attribute cursor conditions
+            if (! empty($cursor) && $vectorDistance !== null) {
+                $distance = $cursor[Document::DISTANCE] ?? null;
+                if (! \is_numeric($distance)) {
+                    throw new QueryException('Vector cursor is missing its distance');
+                }
+                if (empty($orderAttributes)) {
+                    throw new QueryException('Vector cursor requires a unique order attribute');
+                }
+
+                $vectorCursor = $this->getVectorCursorCondition(
+                    $vectorDistance,
+                    (float) $distance,
+                    \array_values($orderAttributes),
+                    \array_values($orderTypes),
+                    $cursor,
+                    $cursorDirection,
+                    $alias,
+                    $resolveInternalKey,
+                );
+                $builder->whereRaw($vectorCursor['expression'], $vectorCursor['bindings']);
+            }
+
+            if ($vectorDistance === null) {
+                $this->applyFindCursor(
+                    $builder,
+                    $orderAttributes,
+                    $orderTypes,
+                    $cursor,
+                    $cursorDirection,
+                    $resolveInternalKey,
+                );
+            }
+
+            // Vector ordering (comes first for similarity search)
+            if ($vectorDistance !== null) {
+                $vectorOrder = $vectorDistance['expression'];
+                if (! empty($cursor) && $cursorDirection === CursorDirection::Before) {
+                    $vectorOrder .= ' DESC';
+                }
+                $builder->orderByRaw($vectorOrder, $vectorDistance['bindings']);
+            }
+
+            if ($vectorDistance !== null && ! $hasAggregation) {
+                if (! $hasSelectionProjection) {
+                    $builder->select(['*']);
+                }
+                $builder->selectRaw(
+                    $this->getSQLReadableDistance($vectorDistance['expression']).' AS '.$this->quote(Storage::DISTANCE),
+                    $vectorDistance['bindings']
+                );
+            }
+
+            // Full-text search relevance scoring.
+            //
+            // Skip the second MATCH compilation (and its ORDER BY) when the caller
+            // already asked for an explicit order. The Documents trait auto-appends
+            // the sequence attribute as a tiebreaker, so a single sequence-only
+            // signal — with no entries before it — means "caller did not specify
+            // an order" and is the only case where we should auto-order by
+            // relevance. Anything else (multiple entries, or a leading attribute
+            // other than sequence) means the caller has an explicit order and
+            // relevance ordering would silently override it.
+            $shouldAutoOrderByRelevance = (
+                count($orderAttributes) === 0
+                || (count($orderAttributes) === 1 && $orderAttributes[0] === Document::SEQUENCE)
+            );
+
+            if (! empty($searchQueries) && $shouldAutoOrderByRelevance) {
+                $builder->select(['*']);
+                foreach ($searchQueries as $searchQuery) {
+                    $relevanceRaw = $this->getSearchRelevanceRaw($searchQuery, $alias);
+                    if ($relevanceRaw !== null) {
+                        $builder->selectRaw($relevanceRaw['expression'], $relevanceRaw['bindings']);
+                        $builder->orderByRaw($relevanceRaw['order']);
+                    }
+                }
+            }
+
+            $this->applyFindPage($builder, $orderAttributes, $orderTypes, $limit, $offset, $cursorDirection, joinAliases: $joinAliases);
+            $results = $this->executeSelect($builder, Event::DocumentFind);
+        }
+
+        $documents = [];
+
+        if ($hasAggregation) {
+            foreach ($results as $row) {
+                /** @var array<string, mixed> $row */
+                $documents[] = Document::fromRow($row);
+            }
+
+            return $documents;
+        }
+
+        foreach ($results as $row) {
+            /** @var array<string, mixed> $row */
+            $this->remapRow($row);
+            $documents[] = Document::fromRow($row);
+        }
+
+        if ($cursorDirection === CursorDirection::Before) {
+            $documents = \array_reverse($documents);
+        }
+
+        return $documents;
     }
 
     /**
-     * Is index supported?
+     * @param array<mixed> $bindings
+     * @return array<Document>
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForIndex(): bool
+    public function rawQuery(string $query, array $bindings = []): array
     {
-        return true;
+        try {
+            $stmt = $this->prepareStatement($query);
+            foreach ($bindings as $i => $value) {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
+            }
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        $results = $stmt->fetchAll();
+        $stmt->closeCursor();
+
+        $documents = [];
+        foreach ($results as $row) {
+            /** @var array<string, mixed> $row */
+            $documents[] = Document::fromRow($row);
+        }
+
+        return $documents;
     }
 
     /**
-     * Are attributes supported?
+     * Count Documents
      *
-     * @return bool
+     * @param  array<Query>  $queries
+     *
+     * @throws Exception
+     * @throws PDOException
      */
-    public function getSupportForAttributes(): bool
+    public function count(Document $collection, array $queries = [], ?int $max = null): int
     {
-        return true;
+        $collectionDoc = $collection;
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
+
+        // count() forwards queries to filter() without mutating individual
+        // Query objects, so cloning is gratuitous on the hot path.
+        $otherQueries = [];
+        $hasJoins = false;
+        foreach ($queries as $query) {
+            if ($query->getMethod()->isVector()) {
+                continue;
+            }
+            $otherQueries[] = $query;
+            if ($query->getMethod()->isJoin()) {
+                $hasJoins = true;
+            }
+        }
+
+        if ($hasJoins) {
+            $innerBuilder = $this->configureCountBuilder(
+                $collectionDoc,
+                $otherQueries,
+                $name,
+                $alias,
+                $roles,
+                $max,
+            );
+
+            return $this->executeWrappedCount($innerBuilder);
+        }
+
+        // Fast path: no filters, no permission subquery, no shared-tenant
+        // filter, no max. The Builder produces ~30 lines of SQL; bypassing
+        // it for the common "count all rows" case dodges thousands of PHP
+        // ops per call.
+        if (
+            empty($otherQueries)
+            && $max === null
+            && ! $this->authorization->getStatus()
+            && ! ($this->sharedTables && $this->tenant !== null)
+        ) {
+            $sql = "SELECT COUNT(1) AS {$this->quote('sum')} FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}";
+
+            try {
+                $stmt = $this->prepareStatement($sql, Event::DocumentCount);
+                $this->execute($stmt);
+            } catch (PDOException $e) {
+                throw $this->processException($e);
+            }
+
+            /** @var array<string, mixed>|false $row */
+            $row = $stmt->fetch();
+            $stmt->closeCursor();
+
+            return is_array($row) && is_numeric($row['sum'] ?? null) ? (int) $row['sum'] : 0;
+        }
+
+        // Build inner query: SELECT 1 FROM table WHERE ... LIMIT
+        $innerBuilder = $this->newBuilder($name, $alias);
+        $innerBuilder->selectRaw('1');
+        $innerBuilder->filter($otherQueries);
+
+        // Permission subquery
+        if ($this->authorization->getStatus()) {
+            $innerBuilder->addHook($this->newPermissionHook($name, $roles));
+        }
+
+        if (! \is_null($max)) {
+            $innerBuilder->limit($max);
+        }
+
+        return $this->executeWrappedCount($innerBuilder);
     }
 
     /**
-     * Is unique index supported?
+     * Sum an Attribute
      *
-     * @return bool
+     * @param  array<Query>  $queries
+     *
+     * @throws Exception
+     * @throws PDOException
      */
-    public function getSupportForUniqueIndex(): bool
+    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): int|float
     {
-        return true;
+        $collectionDoc = $collection;
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
+
+        // sum() forwards queries to filter() without mutating individual
+        // Query objects, so cloning is gratuitous on the hot path.
+        $otherQueries = [];
+        $hasJoins = false;
+        foreach ($queries as $query) {
+            if ($query->getMethod()->isVector()) {
+                continue;
+            }
+            $otherQueries[] = $query;
+            if ($query->getMethod()->isJoin()) {
+                $hasJoins = true;
+            }
+        }
+
+        if ($hasJoins) {
+            $innerBuilder = $this->configureCountBuilder(
+                $collectionDoc,
+                $otherQueries,
+                $name,
+                $alias,
+                $roles,
+                $max,
+                $attribute,
+            );
+
+            return $this->executeWrappedSum($innerBuilder, 'sum_attr');
+        }
+
+        $attribute = $this->filter($attribute);
+
+        // Fast path: trivial SUM(column) over the entire collection. Bypass
+        // the Builder's full SELECT/FROM/WHERE pipeline.
+        if (
+            empty($otherQueries)
+            && $max === null
+            && ! $this->authorization->getStatus()
+            && ! ($this->sharedTables && $this->tenant !== null)
+        ) {
+            $sql = "SELECT SUM({$this->quote($attribute)}) AS {$this->quote('sum')} FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}";
+
+            try {
+                $stmt = $this->prepareStatement($sql, Event::DocumentSum);
+                $this->execute($stmt);
+            } catch (PDOException $e) {
+                throw $this->processException($e);
+            }
+
+            /** @var array<string, mixed>|false $row */
+            $row = $stmt->fetch();
+            $stmt->closeCursor();
+            $sumVal = is_array($row) ? ($row['sum'] ?? 0) : 0;
+
+            if (is_numeric($sumVal)) {
+                return str_contains((string) $sumVal, '.') ? (float) $sumVal : (int) $sumVal;
+            }
+
+            return 0;
+        }
+
+        // Build inner query: SELECT attribute FROM table WHERE ... LIMIT
+        $innerBuilder = $this->newBuilder($name, $alias);
+        $innerBuilder->select([$attribute]);
+        $innerBuilder->filter($otherQueries);
+
+        // Permission subquery
+        if ($this->authorization->getStatus()) {
+            $innerBuilder->addHook($this->newPermissionHook($name, $roles));
+        }
+
+        if (! \is_null($max)) {
+            $innerBuilder->limit($max);
+        }
+
+        return $this->executeWrappedSum($innerBuilder, $attribute);
     }
 
     /**
-     * Is fulltext index supported?
-     *
-     * @return bool
+     * @param  array<Query>  $queries
+     * @param  array<string>  $roles
      */
-    public function getSupportForFulltextIndex(): bool
-    {
-        return true;
+    private function configureCountBuilder(
+        Document $collection,
+        array $queries,
+        string $name,
+        string $alias,
+        array $roles,
+        ?int $max,
+        ?string $sumAttribute = null,
+    ): SQLBuilder {
+        $queries = \array_map(static fn ($query) => clone $query, $queries);
+
+        $adapterFilterQueries = [];
+        $filterQueries = [];
+        foreach ($queries as $query) {
+            if ($this->isAdapterFilterQuery($query)) {
+                $adapterFilterQueries[] = $query;
+
+                continue;
+            }
+            $filterQueries[] = $query;
+        }
+        $queries = $filterQueries;
+
+        $joinTablePrefixes = $this->remapJoinQueries($queries);
+        $selectRaw = $sumAttribute === null
+            ? '1'
+            : $this->qualifySumSelect($sumAttribute, $joinTablePrefixes, $collection).' AS '.$this->quote('sum_attr');
+
+        $hasPreservingOuterJoin = false;
+        foreach ($queries as $query) {
+            $method = $query->getMethod();
+            if ($method === Method::RightJoin || $method === Method::FullOuterJoin) {
+                $hasPreservingOuterJoin = true;
+                break;
+            }
+        }
+
+        if ($this->needsFullOuterJoinEmulation($this->createBuilder(), $queries)) {
+            $leftQueries = $this->rewriteFullOuterJoins($queries, Method::LeftJoin);
+            $rightQueries = $this->rewriteFullOuterJoins($queries, Method::RightJoin);
+            $rightQueries[] = BaseQuery::isNull($alias.'.'.Storage::UID);
+
+            $left = $this->newBuilder($name, $alias, false);
+            $left->selectRaw($selectRaw);
+            $this->applyFindFilters(
+                $left,
+                $collection,
+                $leftQueries,
+                $joinTablePrefixes,
+                $adapterFilterQueries,
+                $name,
+                $alias,
+                $roles,
+                PermissionType::Read,
+                false,
+            );
+
+            $right = $this->newBuilder($name, $alias, true);
+            $right->selectRaw($selectRaw);
+            $this->applyFindFilters(
+                $right,
+                $collection,
+                $rightQueries,
+                $joinTablePrefixes,
+                $adapterFilterQueries,
+                $name,
+                $alias,
+                $roles,
+                PermissionType::Read,
+                true,
+            );
+
+            $left->unionAll($right);
+            if (! \is_null($max)) {
+                $this->applyFindPage($left, [], [], $max, null, afterUnion: true);
+            }
+
+            return $left;
+        }
+
+        $builder = $this->newBuilder($name, $alias, $hasPreservingOuterJoin);
+        $builder->selectRaw($selectRaw);
+        $this->applyFindFilters(
+            $builder,
+            $collection,
+            $queries,
+            $joinTablePrefixes,
+            $adapterFilterQueries,
+            $name,
+            $alias,
+            $roles,
+            PermissionType::Read,
+            $hasPreservingOuterJoin,
+        );
+
+        if (! \is_null($max)) {
+            $builder->limit($max);
+        }
+
+        return $builder;
     }
 
     /**
-     * Are FOR UPDATE locks supported?
-     *
-     * @return bool
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
      */
-    public function getSupportForUpdateLock(): bool
+    private function qualifySumSelect(string $attribute, array $joinTablePrefixes, Document $collection): string
     {
-        return true;
+        $quote = $this->getIdentifierQuoteChar();
+        $aliasSet = \array_fill_keys(\array_column($joinTablePrefixes, 'alias'), true);
+        $aliasSet[Query::DEFAULT_ALIAS] = true;
+        $mainAttributes = [];
+        /** @var array<Document> $collectionAttrs */
+        $collectionAttrs = $collection->getAttribute('attributes', []);
+        foreach ($collectionAttrs as $attr) {
+            $mainAttributes[$attr->getId()] = true;
+        }
+
+        $qualified = $this->qualifyDottedAttribute($attribute, $aliasSet, $mainAttributes);
+        if (! \str_contains($qualified, '.')) {
+            $qualified = Query::DEFAULT_ALIAS.'.'.$qualified;
+        }
+
+        $dot = \strpos($qualified, '.');
+        $prefix = \substr($qualified, 0, (int) $dot);
+        $name = \substr($qualified, (int) $dot + 1);
+
+        return $quote.$prefix.$quote.'.'.$quote.$name.$quote;
     }
 
-    /**
-     * Is Attribute Resizing Supported?
-     *
-     * @return bool
-     */
-    public function getSupportForAttributeResizing(): bool
+    private function executeWrappedCount(SQLBuilder $innerBuilder): int
     {
-        return true;
+        $outerBuilder = $this->createBuilder();
+        $outerBuilder->fromSub($innerBuilder, 'table_count');
+        $outerBuilder->count('1', 'sum');
+
+        $row = $this->fetchAggregateRow($outerBuilder, Event::DocumentCount);
+        $sumInt = $row['sum'] ?? 0;
+
+        return \is_numeric($sumInt) ? (int) $sumInt : 0;
     }
 
-    /**
-     * Are batch operations supported?
-     *
-     * @return bool
-     */
-    public function getSupportForBatchOperations(): bool
+    private function executeWrappedSum(SQLBuilder $innerBuilder, string $attribute): int|float
     {
-        return true;
+        $outerBuilder = $this->createBuilder();
+        $outerBuilder->fromSub($innerBuilder, 'table_count');
+        $outerBuilder->sum($attribute, 'sum');
+
+        $row = $this->fetchAggregateRow($outerBuilder, Event::DocumentSum);
+        $sumVal = $row['sum'] ?? 0;
+
+        if (\is_numeric($sumVal)) {
+            return \str_contains((string) $sumVal, '.') ? (float) $sumVal : (int) $sumVal;
+        }
+
+        return 0;
     }
 
     /**
-     * Is get connection id supported?
-     *
-     * @return bool
+     * @return array<string, mixed>
      */
-    public function getSupportForGetConnectionId(): bool
+    private function fetchAggregateRow(SQLBuilder $builder, Event $event): array
     {
-        return true;
+        $result = $builder->build();
+        $stmt = $this->prepareStatement($result->query, $event);
+        $this->bindStatement($stmt, $result->bindings);
+
+        try {
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        $rows = $stmt->fetchAll();
+        $stmt->closeCursor();
+        if (! empty($rows) && \is_array($rows[0])) {
+            /** @var array<string, mixed> $row */
+            $row = $rows[0];
+
+            return $row;
+        }
+
+        return [];
     }
 
     /**
-     * Is cache fallback supported?
-     *
-     * @return bool
+     * Get max STRING limit
      */
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForCaching(): bool
+    public function getLimitForString(): int
     {
-        return true;
+        return 4294967295;
     }
 
     /**
-     * Is hostname supported?
-     *
-     * @return bool
+     * Get max INT limit
      */
-    public function getSupportForHostname(): bool
+    public function getLimitForInt(): int
     {
-        return true;
+        return 4294967295;
     }
 
     /**
-     * Returns the INSERT keyword, optionally with IGNORE for duplicate handling.
-     * Override in adapter subclasses for DB-specific syntax.
+     * Get max BIGINT limit
      */
-    protected function getInsertKeyword(): string
+    public function getLimitForBigInt(): int
     {
-        return $this->skipDuplicates ? 'INSERT IGNORE INTO' : 'INSERT INTO';
+        return Database::MAX_BIG_INT;
     }
 
     /**
-     * Returns a suffix appended after VALUES clause for duplicate handling.
-     * Override in adapter subclasses (e.g., Postgres uses ON CONFLICT DO NOTHING).
+     * Get maximum column limit.
+     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
+     * Can be inherited by MySQL since we utilize the InnoDB engine
      */
-    protected function getInsertSuffix(string $table): string
+    public function getLimitForAttributes(): int
     {
-        return '';
+        return 1017;
     }
 
     /**
-     * Returns a suffix for the permissions INSERT statement when ignoring duplicates.
-     * Override in adapter subclasses for DB-specific syntax.
+     * Get maximum index limit.
+     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
      */
-    protected function getInsertPermissionsSuffix(): string
+    public function getLimitForIndexes(): int
     {
-        return '';
+        return 64;
     }
 
     /**
      * Get current attribute count from collection document
-     *
-     * @param Document $collection
-     * @return int
      */
     public function getCountOfAttributes(Document $collection): int
     {
-        $attributes = \count($collection->getAttribute('attributes') ?? []);
+        /** @var array<mixed> $attrs */
+        $attrs = $collection->getAttribute('attributes') ?? [];
+        $attributes = \count($attrs);
 
         return $attributes + $this->getCountOfDefaultAttributes();
     }
 
     /**
      * Get current index count from collection document
-     *
-     * @param Document $collection
-     * @return int
      */
     public function getCountOfIndexes(Document $collection): int
     {
-        $indexes = \count($collection->getAttribute('indexes') ?? []);
+        /** @var array<mixed> $idxs */
+        $idxs = $collection->getAttribute('indexes') ?? [];
+        $indexes = \count($idxs);
+
         return $indexes + $this->getCountOfDefaultIndexes();
     }
 
     /**
      * Returns number of attributes used by default.
-     *
-     * @return int
      */
     public function getCountOfDefaultAttributes(): int
     {
-        return \count(Database::INTERNAL_ATTRIBUTES);
+        return \count(Database::internalAttributes());
     }
 
     /**
      * Returns number of indexes used by default.
-     *
-     * @return int
      */
     public function getCountOfDefaultIndexes(): int
     {
@@ -1153,8 +2080,6 @@ public function getCountOfDefaultIndexes(): int
     /**
      * Get maximum width, in bytes, allowed for a SQL row
      * Return 0 when no restrictions apply
-     *
-     * @return int
      */
     public function getDocumentSizeLimit(): int
     {
@@ -1166,8 +2091,6 @@ public function getDocumentSizeLimit(): int
      * Byte requirement varies based on column type and size.
      * Needed to satisfy MariaDB/MySQL row width limit.
      *
-     * @param Document $collection
-     * @return int
      * @throws DatabaseException
      */
     public function getAttributeWidth(Document $collection): int
@@ -1182,81 +2105,109 @@ public function getAttributeWidth(Document $collection): int
          * `_updatedAt` datetime(3) => 7 bytes
          * `_permissions` mediumtext => 20
          */
-
         $total = 1067;
 
+        /** @var array<int, Attribute|Document|array<string, mixed>> $attributes */
         $attributes = $collection->getAttributes()['attributes'] ?? [];
 
         foreach ($attributes as $attribute) {
+            if ($attribute instanceof Attribute) {
+                $isArray = $attribute->array;
+                $attrSize = $attribute->size;
+                $attrType = $attribute->type->value;
+            } elseif ($attribute instanceof Document) {
+                $isArray = (bool) $attribute->getAttribute('array', false);
+                $size = $attribute->getAttribute('size', 0);
+                $attrSize = \is_numeric($size) ? (int) $size : 0;
+                $rawType = $attribute->getAttribute('type', '');
+                if ($rawType instanceof ColumnType) {
+                    $rawType = $rawType->value;
+                }
+                $rawType = \is_scalar($rawType) ? (string) $rawType : '';
+                $normalizedType = Attribute::tryNormalizeType($rawType);
+                $attrType = $normalizedType instanceof ColumnType ? $normalizedType->value : $rawType;
+            } else {
+                $isArray = (bool) ($attribute['array'] ?? false);
+                $attrSize = (int) (is_scalar($attribute['size'] ?? 0) ? ($attribute['size'] ?? 0) : 0);
+                $rawType = $attribute['type'] ?? '';
+                if ($rawType instanceof ColumnType) {
+                    $rawType = $rawType->value;
+                }
+                $rawType = \is_scalar($rawType) ? (string) $rawType : '';
+                $normalizedType = Attribute::tryNormalizeType($rawType);
+                $attrType = $normalizedType instanceof ColumnType ? $normalizedType->value : $rawType;
+            }
+
             /**
              * Json / Longtext
              * only the pointer contributes 20 bytes
              * data is stored externally
              */
-
-            if ($attribute['array'] ?? false) {
+            if ($isArray) {
                 $total += 20;
+
                 continue;
             }
 
-            switch ($attribute['type']) {
-                case Database::VAR_ID:
+            switch ($attrType) {
+                case ColumnType::Id->value:
                     $total += 8; //  BIGINT 8 bytes
                     break;
 
-                case Database::VAR_STRING:
+                case ColumnType::String->value:
                     /**
                      * Text / Mediumtext / Longtext
                      * only the pointer contributes 20 bytes to the row size
                      * data is stored externally
                      */
-
                     $total += match (true) {
-                        $attribute['size'] > $this->getMaxVarcharLength() => 20,
-                        $attribute['size'] > 255 => $attribute['size'] * 4 + 2, //  VARCHAR(>255) + 2 length
-                        default => $attribute['size'] * 4 + 1, //  VARCHAR(<=255) + 1 length
+                        $attrSize > $this->getMaxVarcharLength() => 20,
+                        $attrSize > 255 => $attrSize * 4 + 2, //  VARCHAR(>255) + 2 length
+                        default => $attrSize * 4 + 1, //  VARCHAR(<=255) + 1 length
                     };
 
                     break;
 
-                case Database::VAR_VARCHAR:
+                case ColumnType::Varchar->value:
                     $total += match (true) {
-                        $attribute['size'] > 255 => $attribute['size'] * 4 + 2, //  VARCHAR(>255) + 2 length
-                        default => $attribute['size'] * 4 + 1, //  VARCHAR(<=255) + 1 length
+                        $attrSize > 255 => $attrSize * 4 + 2, //  VARCHAR(>255) + 2 length
+                        default => $attrSize * 4 + 1, //  VARCHAR(<=255) + 1 length
                     };
                     break;
 
-                case Database::VAR_TEXT:
-                case Database::VAR_MEDIUMTEXT:
-                case Database::VAR_LONGTEXT:
+                case ColumnType::Text->value:
+                case ColumnType::MediumText->value:
+                case ColumnType::LongText->value:
                     $total += 20; // Pointer storage for TEXT types
                     break;
 
-                case Database::VAR_INTEGER:
-                    if ($attribute['size'] >= 8) {
+                case ColumnType::Integer->value:
+                    if ($attrSize >= 8) {
                         $total += 8; //  BIGINT 8 bytes
                     } else {
                         $total += 4; // INT 4 bytes
                     }
                     break;
 
-                case Database::VAR_BIGINT:
-                    $total += 8; //  BIGINT 8 bytes
+                case ColumnType::BigInteger->value:
+                case ColumnType::BigSerial->value:
+                    $total += 8;
                     break;
 
-                case Database::VAR_FLOAT:
+                case ColumnType::Float->value:
+                case ColumnType::Double->value:
                     $total += 8; // DOUBLE 8 bytes
                     break;
 
-                case Database::VAR_BOOLEAN:
+                case ColumnType::Boolean->value:
                     $total += 1; // TINYINT(1) 1 bytes
                     break;
 
-                case Database::VAR_RELATIONSHIP:
+                case ColumnType::Relationship->value:
                     $total += Database::LENGTH_KEY * 4 + 1; // VARCHAR(<=255)
                     break;
 
-                case Database::VAR_DATETIME:
+                case ColumnType::Datetime->value:
                     /**
                      * 1 byte year + month
                      * 1 byte for the day
@@ -1266,7 +2217,7 @@ public function getAttributeWidth(Document $collection): int
                     $total += 7;
                     break;
 
-                case Database::VAR_OBJECT:
+                case ColumnType::Object->value:
                     /**
                      * JSONB/JSON type
                      * Only the pointer contributes 20 bytes to the row size
@@ -1275,27 +2226,65 @@ public function getAttributeWidth(Document $collection): int
                     $total += 20;
                     break;
 
-                case Database::VAR_POINT:
+                case ColumnType::Point->value:
                     $total += $this->getMaxPointSize();
                     break;
-                case Database::VAR_LINESTRING:
-                case Database::VAR_POLYGON:
+                case ColumnType::Linestring->value:
+                case ColumnType::Polygon->value:
                     $total += 20;
                     break;
 
-                case Database::VAR_VECTOR:
+                case ColumnType::Vector->value:
                     // Each dimension is typically 4 bytes (float32)
-                    $total += ($attribute['size'] ?? 0) * 4;
+                    $total += $attrSize * 4;
                     break;
 
                 default:
-                    throw new DatabaseException('Unknown type: ' . $attribute['type']);
+                    throw new DatabaseException('Unknown type: ' . $attrType);
             }
         }
 
         return $total;
     }
 
+    /**
+     * Get the maximum VARCHAR column length supported across SQL engines.
+     *
+     * @return int
+     */
+    public function getMaxVarcharLength(): int
+    {
+        return 16381; // Floor value for Postgres:16383 | MySQL:16381 | MariaDB:16382
+    }
+
+    /**
+     * Size of POINT spatial type
+     */
+    abstract protected function getMaxPointSize(): int;
+
+    /**
+     * Get the maximum combined index key length in bytes.
+     *
+     * @return int
+     */
+    public function getMaxIndexLength(): int
+    {
+        /**
+         * $tenant int = 1
+         */
+        return $this->sharedTables ? 767 : 768;
+    }
+
+    /**
+     * Get the maximum length for unique document IDs.
+     *
+     * @return int
+     */
+    public function getMaxUIDLength(): int
+    {
+        return 36;
+    }
+
     /**
      * Get list of keywords that cannot be used
      *  Refference: https://mariadb.com/kb/en/reserved-words/
@@ -1578,2027 +2567,3258 @@ public function getKeywords(): array
             'SYSTEM',
             'SYSTEM_TIME',
             'VERSIONING',
-            'WITHOUT'
+            'WITHOUT',
         ];
     }
 
     /**
-     * Does the adapter handle casting?
+     * Get the keys of internally managed indexes.
      *
-     * @return bool
+     * @return array<string>
      */
-    public function getSupportForCasting(): bool
+    public function getInternalIndexesKeys(): array
     {
-        return true;
+        return [Storage::INDEX_PRIMARY, Storage::INDEX_CREATED_AT, Storage::INDEX_UPDATED_AT, Storage::INDEX_TENANT_ID];
     }
 
-    public function getSupportForNumericCasting(): bool
+    /**
+     * Get the minimum supported datetime value.
+     *
+     * @return \DateTime
+     */
+    public function getMinDateTime(): \DateTime
     {
-        return false;
+        return new \DateTime('1000-01-01 00:00:00');
     }
 
-
     /**
-     * Does the adapter handle Query Array Contains?
+     * Analyze a collection, updating its metadata on the database engine.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForQueryContains(): bool
+    public function analyzeCollection(string $collection): bool
     {
-        return true;
+        return false;
     }
 
     /**
-     * Does the adapter handle array Overlaps?
+     * Delete a database schema.
      *
-     * @return bool
+     * @throws Exception
+     * @throws PDOException
      */
-    abstract public function getSupportForJSONOverlaps(): bool;
-
-    public function getSupportForIndexArray(): bool
+    public function delete(string $name): bool
     {
-        return true;
-    }
+        $name = $this->filter($name);
 
-    public function getSupportForCastIndexArray(): bool
-    {
-        return false;
-    }
+        $result = $this->createSchemaBuilder()->dropDatabase($name);
+        $sql = $result->query;
 
-    public function getSupportForRelationships(): bool
-    {
-        return true;
+        return $this->executeStatement($sql, Event::DatabaseDelete);
     }
 
-    public function getSupportForReconnection(): bool
+    /**
+     * Delete a collection and its permissions table.
+     *
+     * @throws DatabaseException
+     */
+    public function deleteCollection(string $id): bool
     {
-        return true;
-    }
+        $id = $this->filter($id);
 
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
+        $schema = $this->createSchemaBuilder();
+        $mainResult = $schema->table($this->getSQLTableRaw($id))->drop();
+        $permsResult = $schema->table($this->getSQLTableRaw(Storage::permissionsTable($id)))->drop();
+
+        $sql = $mainResult->query . '; ' . $permsResult->query;
+
+        $ok = $this->executeStatement($sql, Event::CollectionDelete);
+        // Schema is gone; drop any memoized spatial column list so a later
+        // recreate-with-different-schema doesn't see the stale entry.
+        $this->invalidateSpatialAttributesCache($id);
+
+        return $ok;
     }
 
     /**
-     * Are spatial attributes supported?
+     * Create a relationship between collections by adding foreign key columns.
      *
-     * @return bool
-    */
-    public function getSupportForSpatialAttributes(): bool
+     * @throws DatabaseException
+     */
+    public function createRelationship(Relationship $relationship): bool
     {
-        return false;
+        $name = $this->filter($relationship->collection);
+        $relatedName = $this->filter($relationship->relatedCollection);
+        $id = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $type = $relationship->type;
+        $twoWay = $relationship->twoWay;
+
+        $schema = $this->createSchemaBuilder();
+        $addRelColumn = function (string $tableName, string $columnId) use ($schema): string {
+            $table = $schema->table($this->getSQLTableRaw($tableName));
+            $table->string($columnId, 255)->nullable()->default(null);
+            $result = $table->alter();
+
+            return $result->query;
+        };
+
+        $sql = match ($type) {
+            RelationType::OneToOne => $addRelColumn($name, $id) . ';' . ($twoWay ? $addRelColumn($relatedName, $twoWayKey) . ';' : ''),
+            RelationType::OneToMany => $addRelColumn($relatedName, $twoWayKey) . ';',
+            RelationType::ManyToOne => $addRelColumn($name, $id) . ';',
+            RelationType::ManyToMany => null,
+        };
+
+        if ($sql === null) {
+            return true;
+        }
+
+        return $this->executeStatement($sql, Event::AttributeCreate);
     }
 
     /**
-     * Does the adapter support null values in spatial indexes?
+     * Update a relationship, optionally renaming its keys.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return false;
+    public function updateRelationship(
+        Relationship $relationship,
+        ?string $newKey = null,
+        ?string $newTwoWayKey = null,
+    ): bool {
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $name = $this->filter($collection);
+        $relatedName = $this->filter($relatedCollection);
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $type = $relationship->type;
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
+
+        if ($newKey !== null) {
+            $newKey = $this->filter($newKey);
+        }
+        if ($newTwoWayKey !== null) {
+            $newTwoWayKey = $this->filter($newTwoWayKey);
+        }
+
+        $schema = $this->createSchemaBuilder();
+        $renameCol = function (string $tableName, string $from, string $to) use ($schema): string {
+            $table = $schema->table($this->getSQLTableRaw($tableName));
+            $table->renameColumn($from, $to);
+            $result = $table->alter();
+
+            return $result->query;
+        };
+
+        $sql = '';
+
+        switch ($type) {
+            case RelationType::OneToOne:
+                if ($key !== $newKey && \is_string($newKey)) {
+                    $sql = $renameCol($name, $key, $newKey) . ';';
+                }
+                if ($twoWay && $twoWayKey !== $newTwoWayKey && \is_string($newTwoWayKey)) {
+                    $sql .= $renameCol($relatedName, $twoWayKey, $newTwoWayKey) . ';';
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    if ($twoWayKey !== $newTwoWayKey && \is_string($newTwoWayKey)) {
+                        $sql = $renameCol($relatedName, $twoWayKey, $newTwoWayKey) . ';';
+                    }
+                } else {
+                    if ($key !== $newKey && \is_string($newKey)) {
+                        $sql = $renameCol($name, $key, $newKey) . ';';
+                    }
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
+                    if ($twoWayKey !== $newTwoWayKey && \is_string($newTwoWayKey)) {
+                        $sql = $renameCol($relatedName, $twoWayKey, $newTwoWayKey) . ';';
+                    }
+                } else {
+                    if ($key !== $newKey && \is_string($newKey)) {
+                        $sql = $renameCol($name, $key, $newKey) . ';';
+                    }
+                }
+                break;
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collection = $this->getDocument($metadataCollection, $collection);
+                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
+
+                $junctionName = '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence();
+
+                if ($newKey !== null) {
+                    $sql = $renameCol($junctionName, $key, $newKey) . ';';
+                }
+                if ($twoWay && $newTwoWayKey !== null) {
+                    $sql .= $renameCol($junctionName, $twoWayKey, $newTwoWayKey) . ';';
+                }
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
+
+        if ($sql === '') {
+            return true;
+        }
+
+        return $this->executeStatement($sql, Event::AttributeUpdate);
     }
 
     /**
-     * Does the adapter support operators?
+     * Delete a relationship between collections.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForOperators(): bool
+    public function deleteRelationship(Relationship $relationship): bool
     {
-        return true;
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
+        $name = $this->filter($collection);
+        $relatedName = $this->filter($relatedCollection);
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $type = $relationship->type;
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
+
+        $schema = $this->createSchemaBuilder();
+        $dropCol = function (string $tableName, string $columnId) use ($schema): string {
+            $table = $schema->table($this->getSQLTableRaw($tableName));
+            $table->dropColumn($columnId);
+            $result = $table->alter();
+
+            return $result->query;
+        };
+
+        $sql = '';
+
+        switch ($type) {
+            case RelationType::OneToOne:
+                if ($side === RelationSide::Parent) {
+                    $sql = $dropCol($name, $key) . ';';
+                    if ($twoWay) {
+                        $sql .= $dropCol($relatedName, $twoWayKey) . ';';
+                    }
+                } elseif ($side === RelationSide::Child) {
+                    $sql = $dropCol($relatedName, $twoWayKey) . ';';
+                    if ($twoWay) {
+                        $sql .= $dropCol($name, $key) . ';';
+                    }
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    $sql = $dropCol($relatedName, $twoWayKey) . ';';
+                } else {
+                    $sql = $dropCol($name, $key) . ';';
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    $sql = $dropCol($name, $key) . ';';
+                } else {
+                    $sql = $dropCol($relatedName, $twoWayKey) . ';';
+                }
+                break;
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collection = $this->getDocument($metadataCollection, $collection);
+                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
+
+                $junctionName = $side === RelationSide::Parent
+                    ? '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence()
+                    : '_' . $relatedCollection->getSequence() . '_' . $collection->getSequence();
+
+                $junctionResult = $schema->table($this->getSQLTableRaw($junctionName))->drop();
+                $permsResult = $schema->table($this->getSQLTableRaw(Storage::permissionsTable($junctionName)))->drop();
+
+                $sql = $junctionResult->query . '; ' . $permsResult->query;
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
+
+        return $this->executeStatement($sql, Event::AttributeDelete);
     }
 
     /**
-     * Does the adapter support order attribute in spatial indexes?
+     * Convert a type string and size to the corresponding SQL column type definition.
      *
-     * @return bool
-    */
-    public function getSupportForSpatialIndexOrder(): bool
+     * @param string $type The column type value
+     * @param int $size The column size
+     * @param bool $signed Whether the column is signed
+     * @param bool $array Whether the column stores an array
+     * @param bool $required Whether the column is required
+     * @return string
+     *
+     * @throws DatabaseException For unknown type values.
+     */
+    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
     {
-        return false;
+        $columnType = Attribute::tryNormalizeType($type);
+        if ($columnType === null) {
+            throw new DatabaseException('Unknown column type: '.$type);
+        }
+
+        return $this->getSQLType($columnType, $size, $signed, $array, $required);
     }
 
-    /**
-    * Is internal casting supported?
-    *
-    * @return bool
-    */
-    public function getSupportForInternalCasting(): bool
+    protected function getSQLType(ColumnType $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
     {
-        return false;
+        if (in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+            return $this->getSpatialSQLType($type->value, $required);
+        }
+        if ($array === true) {
+            return 'JSON';
+        }
+
+        if ($type === ColumnType::String) {
+            if ($size > 16777215) {
+                return 'LONGTEXT';
+            }
+            if ($size > 65535) {
+                return 'MEDIUMTEXT';
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                return 'TEXT';
+            }
+
+            return "VARCHAR({$size})";
+        }
+
+        if ($type === ColumnType::Varchar) {
+            if ($size <= 0) {
+                throw new DatabaseException('VARCHAR size ' . $size . ' is invalid; must be > 0. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                throw new DatabaseException('VARCHAR size ' . $size . ' exceeds maximum varchar length ' . $this->getMaxVarcharLength() . '. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
+            }
+
+            return "VARCHAR({$size})";
+        }
+
+        if (\in_array($type, [ColumnType::Integer, ColumnType::BigInteger, ColumnType::BigSerial], true)) {
+            $suffix = $signed ? '' : ' UNSIGNED';
+
+            return ($type === ColumnType::Integer && $size < 8 ? 'INT' : 'BIGINT') . $suffix;
+        }
+
+        if ($type === ColumnType::Float || $type === ColumnType::Double) {
+            return 'DOUBLE' . ($signed ? '' : ' UNSIGNED');
+        }
+
+        return match ($type) {
+            ColumnType::Id => 'BIGINT UNSIGNED',
+            ColumnType::Text => 'TEXT',
+            ColumnType::MediumText => 'MEDIUMTEXT',
+            ColumnType::LongText => 'LONGTEXT',
+            ColumnType::Boolean => 'TINYINT(1)',
+            ColumnType::Relationship => 'VARCHAR(255)',
+            ColumnType::Datetime => 'DATETIME(3)',
+            default => throw new DatabaseException('Unknown type: ' . $type->value . '. Must be one of ' . ColumnType::String->value . ', ' . ColumnType::Varchar->value . ', ' . ColumnType::Text->value . ', ' . ColumnType::MediumText->value . ', ' . ColumnType::LongText->value . ', ' . ColumnType::Integer->value . ', ' . ColumnType::Double->value . ', ' . ColumnType::Boolean->value . ', ' . ColumnType::Datetime->value . ', ' . ColumnType::Relationship->value . ', ' . ColumnType::Point->value . ', ' . ColumnType::Linestring->value . ', ' . ColumnType::Polygon->value),
+        };
     }
 
     /**
-     * Does the adapter support multiple fulltext indexes?
+     * Get the SQL type definition for spatial column types.
      *
-     * @return bool
+     * @param string $type The spatial type (point, linestring, polygon)
+     * @param bool $required Whether the column is NOT NULL
+     * @return string
      */
-    public function getSupportForMultipleFulltextIndexes(): bool
+    protected function getSpatialSQLType(string $type, bool $required): string
     {
-        return true;
+        $srid = Database::DEFAULT_SRID;
+        $nullability = '';
+
+        if (! $this->supports(Capability::SpatialIndexNull)) {
+            if ($required) {
+                $nullability = ' NOT NULL';
+            } else {
+                $nullability = ' NULL';
+            }
+        }
+
+        return match ($type) {
+            ColumnType::Point->value => "POINT($srid)$nullability",
+            ColumnType::Linestring->value => "LINESTRING($srid)$nullability",
+            ColumnType::Polygon->value => "POLYGON($srid)$nullability",
+            default => '',
+        };
     }
 
     /**
-     * Does the adapter support identical indexes?
+     * Get SQL Index Type
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForIdenticalIndexes(): bool
+    protected function getSQLIndexType(IndexType $type): string
     {
-        return true;
+        return match ($type) {
+            IndexType::Key => 'INDEX',
+            IndexType::Unique => 'UNIQUE INDEX',
+            IndexType::Fulltext => 'FULLTEXT INDEX',
+            default => throw new DatabaseException('Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value),
+        };
     }
 
     /**
-     * Does the adapter support random order for queries?
+     * Extract the spatial geometry type name from a WKT string.
      *
-     * @return bool
+     * @param string $wkt The Well-Known Text representation
+     * @return string The lowercase type name (e.g. "point", "polygon")
+     *
+     * @throws DatabaseException If the WKT is invalid.
      */
-    public function getSupportForOrderRandom(): bool
+    public function getSpatialTypeFromWKT(string $wkt): string
     {
-        return true;
+        $wkt = trim($wkt);
+        $pos = strpos($wkt, '(');
+        if ($pos === false) {
+            throw new DatabaseException('Invalid spatial type');
+        }
+
+        return strtolower(trim(substr($wkt, 0, $pos)));
     }
 
-    public function getSupportForUTCCasting(): bool
+    /**
+     * Generate ST_GeomFromText call with proper SRID and axis order support
+     */
+    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
     {
-        return false;
+        $srid = $srid ?? Database::DEFAULT_SRID;
+        $geomFromText = "ST_GeomFromText({$wktPlaceholder}, {$srid}";
+
+        if ($this->supports(Capability::SpatialAxisOrder)) {
+            $geomFromText .= ', '.$this->getSpatialAxisOrderSpec();
+        }
+
+        $geomFromText .= ')';
+
+        return $geomFromText;
     }
 
-    public function setUTCDatetime(string $value): mixed
+    /**
+     * Get the spatial axis order specification string
+     */
+    protected function getSpatialAxisOrderSpec(): string
     {
-        return $value;
+        return "'axis-order=long-lat'";
     }
 
-    public function castingBefore(Document $collection, Document $document): Document
+    protected function isSpatialWkt(mixed $value): bool
     {
-        return $document;
+        return \is_string($value) && \preg_match('/^(POINT|LINESTRING|POLYGON)\s*\(/i', $value) === 1;
     }
 
-    public function castingAfter(Document $collection, Document $document): Document
+    /**
+     * @param  array<mixed>  $geometry
+     *
+     * @throws DatabaseException
+     */
+    protected function convertArrayToWKT(array $geometry): string
     {
-        return $document;
-    }
+        if ($geometry === [] || ! \array_is_list($geometry)) {
+            throw new DatabaseException('Unrecognized geometry array format');
+        }
+
+        // point [x, y]
+        if (count($geometry) === 2 && is_numeric($geometry[0]) && is_numeric($geometry[1])) {
+            return "POINT({$geometry[0]} {$geometry[1]})";
+        }
+
+        // linestring [[x1, y1], [x2, y2], ...]
+        if (is_array($geometry[0]) && count($geometry[0]) === 2 && is_numeric($geometry[0][0])) {
+            $points = [];
+            foreach ($geometry as $point) {
+                if (! is_array($point) || count($point) !== 2 || ! is_numeric($point[0]) || ! is_numeric($point[1])) {
+                    throw new DatabaseException('Invalid point format in geometry array');
+                }
+                $points[] = "{$point[0]} {$point[1]}";
+            }
+
+            return 'LINESTRING('.implode(', ', $points).')';
+        }
+
+        // polygon [[[x1, y1], [x2, y2], ...], ...]
+        if (is_array($geometry[0]) && is_array($geometry[0][0]) && count($geometry[0][0]) === 2) {
+            $rings = [];
+            foreach ($geometry as $ring) {
+                if (! is_array($ring)) {
+                    throw new DatabaseException('Invalid ring format in polygon geometry');
+                }
+                $points = [];
+                foreach ($ring as $point) {
+                    if (! is_array($point) || count($point) !== 2 || ! is_numeric($point[0]) || ! is_numeric($point[1])) {
+                        throw new DatabaseException('Invalid point format in polygon ring');
+                    }
+                    $points[] = "{$point[0]} {$point[1]}";
+                }
+                $rings[] = '('.implode(', ', $points).')';
+            }
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+            return 'POLYGON('.implode(', ', $rings).')';
+        }
 
-    /**
-     * Is vector type supported?
-     *
-     * @return bool
-     */
-    public function getSupportForVectors(): bool
-    {
-        return false;
+        throw new DatabaseException('Unrecognized geometry array format');
     }
 
     /**
-     * Generate ST_GeomFromText call with proper SRID and axis order support
+     * Get SQL table
      *
-     * @param string $wktPlaceholder
-     * @param int|null $srid
-     * @return string
+     * @throws DatabaseException
      */
-    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
+    protected function getSQLTable(string $name): string
     {
-        $srid = $srid ?? Database::DEFAULT_SRID;
-        $geomFromText = "ST_GeomFromText({$wktPlaceholder}, {$srid}";
-
-        if ($this->getSupportForSpatialAxisOrder()) {
-            $geomFromText .= ", " . $this->getSpatialAxisOrderSpec();
-        }
-
-        $geomFromText .= ")";
-
-        return $geomFromText;
+        return "{$this->quote($this->getDatabase())}.{$this->quote($this->getNamespace().'_'.$this->filter($name))}";
     }
 
     /**
-     * Get the spatial axis order specification string
+     * Get an unquoted qualified table name (the builder handles quoting).
      *
-     * @return string
+     * @throws DatabaseException
      */
-    protected function getSpatialAxisOrderSpec(): string
+    protected function getSQLTableRaw(string $name): string
     {
-        return "'axis-order=long-lat'";
+        return $this->getDatabase().'.'.$this->getNamespace().'_'.$this->filter($name);
     }
 
     /**
-     * @param string $tableName
-     * @param string $columns
-     * @param array<string> $batchKeys
-     * @param array<mixed> $bindValues
-     * @param array<string> $attributes
-     * @param string $attribute
-     * @param array<Operator> $operators
-     * @return mixed
+     * Create a new query builder instance for this adapter's SQL dialect.
      */
-    abstract protected function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = []
-    ): mixed;
+    abstract protected function createBuilder(): SQLBuilder;
 
     /**
-     * Get the SQL expression measuring distance between a vector attribute and the query vector
-     *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $alias
-     * @return string|null
+     * Create a new schema builder instance for this adapter's SQL dialect.
      */
-    protected function getSQLVectorDistance(Query $query, array &$binds, string $alias): ?string
+    protected function createSchemaBuilder(): MySQLSchema|PostgreSQLSchema
     {
-        return null;
+        return new MySQLSchema();
     }
 
     /**
-     * Render a vector distance expression in a form safe to read back into PHP
+     * Create and configure a new query builder for a given table.
      *
-     * A distance is undefined for a zero vector and can overflow for a large one, so the
-     * expression can evaluate to NaN or infinity. Those cannot survive the trip into a PHP
-     * float, so the value is carried as text and interpreted during hydration.
+     * Automatically applies tenant filtering when shared tables are enabled.
      *
-     * @param string $distance
-     * @return string
+     * @throws DatabaseException
      */
-    protected function getSQLReadableDistance(string $distance): string
+    protected function newBuilder(string $table, string $alias = '', bool $allowNullTenant = false): SQLBuilder
     {
-        return $distance;
+        $builder = $this->createBuilder()->from($this->getSQLTableRaw($table), $alias);
+
+        // AttributeMap is a readonly stateless config object — share one
+        // instance across builders to avoid allocating it on every read.
+        $this->attributeMap ??= new AttributeMap(Storage::attributeMap());
+        $builder->addHook($this->attributeMap);
+        if ($this->sharedTables && $this->tenant !== null) {
+            $allowNullColumn = '';
+            if ($allowNullTenant) {
+                $allowNullColumn = ($alias !== '' ? $alias : $table).'.'.Storage::TENANT;
+            }
+            $builder->addHook(new TenantFilter(
+                $this->tenant,
+                Database::METADATA,
+                $table,
+                $allowNullColumn,
+                $this->getIdentifierQuoteChar(),
+            ));
+        }
+
+        return $builder;
     }
 
-    /**
-     * @param string $value
-     * @return string
-     */
-    protected function getFulltextValue(string $value): string
+    public function rawMutation(string $query, array $bindings = []): int
     {
-        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
-
-        /** Keep only unicode letters, numbers, underscores, and whitespace. */
-        $value = preg_replace('/[^\p{L}\p{N}_\s]/u', ' ', $value) ?? '';
-        $value = preg_replace('/\s+/', ' ', $value) ?? '';
-        $value = trim($value);
-
-        if (empty($value)) {
-            return '';
+        try {
+            $stmt = $this->prepareStatement($query);
+            foreach ($bindings as $i => $value) {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
+            }
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        if ($exact) {
-            $value = '"' . $value . '"';
-        } else {
-            /** Prepend wildcard by default on the back. */
-            $value .= '*';
-        }
+        $count = $stmt->rowCount();
+        $stmt->closeCursor();
 
-        return $value;
+        return $count;
     }
 
-    /**
-     * Get SQL Operator
-     *
-     * @param string $method
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLOperator(string $method): string
+    public function getBuilder(string $collection): SQLBuilder
     {
-        switch ($method) {
-            case Query::TYPE_EQUAL:
-                return '=';
-            case Query::TYPE_NOT_EQUAL:
-                return '!=';
-            case Query::TYPE_LESSER:
-                return '<';
-            case Query::TYPE_LESSER_EQUAL:
-                return '<=';
-            case Query::TYPE_GREATER:
-                return '>';
-            case Query::TYPE_GREATER_EQUAL:
-                return '>=';
-            case Query::TYPE_IS_NULL:
-                return 'IS NULL';
-            case Query::TYPE_IS_NOT_NULL:
-                return 'IS NOT NULL';
-            case Query::TYPE_STARTS_WITH:
-            case Query::TYPE_ENDS_WITH:
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
-            case Query::TYPE_CONTAINS_ALL:
-            case Query::TYPE_NOT_STARTS_WITH:
-            case Query::TYPE_NOT_ENDS_WITH:
-            case Query::TYPE_NOT_CONTAINS:
-                return $this->getLikeOperator();
-            case Query::TYPE_REGEX:
-                return $this->getRegexOperator();
-            case Query::TYPE_VECTOR_DOT:
-            case Query::TYPE_VECTOR_COSINE:
-            case Query::TYPE_VECTOR_EUCLIDEAN:
-                throw new DatabaseException('Vector queries are not supported by this database');
-            case Query::TYPE_EXISTS:
-            case Query::TYPE_NOT_EXISTS:
-                throw new DatabaseException('Exists queries are not supported by this database');
-            default:
-                throw new DatabaseException('Unknown method: ' . $method);
-        }
+        return $this->newBuilder($this->filter($collection));
     }
 
-    abstract protected function getSQLType(
-        string $type,
-        int $size,
-        bool $signed = true,
-        bool $array = false,
-        bool $required = false
-    ): string;
+    public function getSchema(): Schema
+    {
+        return $this->createSchemaBuilder();
+    }
 
-    /**
-     * @throws DatabaseException For unknown type values.
-     */
-    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    protected function getIdentifierQuoteChar(): string
     {
-        return $this->getSQLType($type, $size, $signed, $array, $required);
+        return '`';
     }
 
     /**
-     * Get SQL Index Type
-     *
-     * @param string $type
-     * @return string
-     * @throws Exception
+     * @param  array<string>  $roles
      */
-    protected function getSQLIndexType(string $type): string
+    protected function newPermissionHook(string $collection, array $roles, string $type = PermissionType::Read->value, string $documentColumn = Storage::UID): PermissionFilter
     {
-        return match ($type) {
-            Database::INDEX_KEY => 'INDEX',
-            Database::INDEX_UNIQUE => 'UNIQUE INDEX',
-            Database::INDEX_FULLTEXT => 'FULLTEXT INDEX',
-            default => throw new DatabaseException('Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT),
-        };
+        return new PermissionFilter(
+            roles: \array_values($roles),
+            permissionsTable: fn (string $table) => $this->getSQLTableRaw(Storage::permissionsTable($collection)),
+            type: $type,
+            documentColumn: $documentColumn,
+            permDocumentColumn: Storage::PERM_DOCUMENT,
+            permRoleColumn: Storage::PERM_PERMISSION,
+            permTypeColumn: Storage::PERM_TYPE,
+            subqueryFilter: ($this->sharedTables && $this->tenant !== null) ? new TenantFilter($this->tenant) : null,
+            quoteChar: $this->getIdentifierQuoteChar(),
+        );
     }
 
     /**
-     * Get SQL condition for permissions
+     * Synchronize write hooks with current adapter configuration.
      *
-     * @param string $collection
-     * @param array<string> $roles
-     * @param string $alias
-     * @param string $type
-     * @return string
-     * @throws DatabaseException
+     * Ensures Permission is always registered and Tenant is registered
+     * when shared tables with a tenant are active.
      */
-    protected function getSQLPermissionsCondition(
-        string $collection,
-        array $roles,
-        string $alias,
-        string $type = Database::PERMISSION_READ
-    ): string {
-        if (!\in_array($type, Database::PERMISSIONS)) {
-            throw new DatabaseException('Unknown permission type: ' . $type);
+    protected function syncWriteHooks(): void
+    {
+        $this->removeWriteHook(Tenancy::class);
+        if ($this->sharedTables && $this->tenant !== null) {
+            $this->addWriteHook(new Tenancy($this->tenant));
         }
-
-        $roles = \array_map(fn ($role) => $this->getPDO()->quote($role), $roles);
-        $roles = \implode(', ', $roles);
-
-        return "{$this->quote($alias)}.{$this->quote('_uid')} IN (
-            SELECT _document
-            FROM {$this->getSQLTable($collection . '_perms')}
-            WHERE _permission IN ({$roles})
-              AND _type = '{$type}'
-              {$this->getTenantQuery($collection)}
-        )";
     }
 
     /**
-     * Get SQL table
+     * Build a WriteContext that delegates to this adapter's query infrastructure.
      *
-     * @param string $name
-     * @return string
-     * @throws DatabaseException
+     * @param  string  $collection  The filtered collection name
+     * @param  string|null  $lookupId  The document id used to load/update this write
      */
-    protected function getSQLTable(string $name): string
+    protected function buildWriteContext(string $collection, ?string $lookupId = null): WriteContext
     {
-        return "{$this->quote($this->getDatabase())}.{$this->quote($this->getNamespace() . '_' .$this->filter($name))}";
+        $name = $this->filter($collection);
+
+        return new WriteContext(
+            newBuilder: fn (string $table, string $alias = '') => $this->newBuilder($table, $alias),
+            executeResult: fn (Statement $result, ?Event $event = null) => $this->executeResult($result, $event),
+            execute: fn (mixed $stmt) => $this->execute($stmt),
+            decorateRow: fn (array $row, array $metadata) => $this->decorateRow($row, $metadata),
+            createBuilder: fn () => $this->createBuilder(),
+            getTableRaw: fn (string $table) => $this->getSQLTableRaw($table),
+            skipDuplicates: $this->skipDuplicates,
+            lookupId: $lookupId,
+        );
     }
 
     /**
-     * Generate SQL expression for operator
-     * Each adapter must implement operators specific to their SQL dialect
+     * Execute a Statement through the transformation system with positional bindings.
      *
-     * @param string $column
-     * @param Operator $operator
-     * @param array<string, mixed> $binds
-     * @return string|null Returns null if operator can't be expressed in SQL
+     * Prepares the SQL statement and binds positional parameters from the Statement.
+     * Does NOT call execute() - the caller is responsible for that.
+     *
+     * @param  Event|null  $event  Optional event to run through transformation system
+     * @return PDOStatement|DatabasePDOStatement|PDOStatementProxy
      */
-    abstract protected function getOperatorSQL(string $column, Operator $operator, array &$binds): ?string;
+    protected function executeResult(Statement $result, ?Event $event = null): PDOStatement|DatabasePDOStatement|PDOStatementProxy
+    {
+        $stmt = $this->prepareStatement($result->query, $event);
+        foreach ($result->bindings as $i => $value) {
+            if (\is_bool($value) && $this->supports(Capability::IntegerBooleans)) {
+                $value = (int) $value;
+            }
+            if (\is_float($value)) {
+                $stmt->bindValue($i + 1, $this->getFloatPrecision($value), PDO::PARAM_STR);
+            } else {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
+            }
+        }
+
+        return $stmt;
+    }
 
     /**
-     * Register an operator bind value and return its placeholder name (without leading colon).
-     * Lets getOperatorSQL() capture a parameter's value as it emits the placeholder, so SQL and
-     * binds can never drift out of sync. The placeholder is unique by construction (ID::unique()),
-     * so no shared counter needs to be threaded between callers.
-     *
-     * @param array<string, mixed> $binds
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
      */
-    protected function registerOperatorBind(array &$binds, mixed $value): string
+    protected function execute(mixed $stmt, ?Event $event = null): bool
     {
-        $key = ID::unique();
-        $binds[":{$key}"] = $value;
-        return $key;
+        if ($this->profiler !== null && $this->profiler->isEnabled()) {
+            $start = \microtime(true);
+            $result = $stmt->execute();
+            $durationMs = (\microtime(true) - $start) * 1000;
+            $this->profiler->log(
+                $stmt->queryString ?? '',
+                [],
+                $durationMs,
+            );
+
+            return $result;
+        }
+
+        return $stmt->execute();
     }
 
     /**
-     * Apply an operator to a value (used for new documents with only operators).
-     * This method applies the operator logic in PHP to compute what the SQL would compute.
-     *
-     * @param Operator $operator
-     * @param mixed $value The current value (typically the attribute default)
-     * @return mixed The result after applying the operator
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
      */
-    protected function applyOperatorToValue(Operator $operator, mixed $value): mixed
+    protected function getStatementEvent(PDOStatement|DatabasePDOStatement|PDOStatementProxy $stmt): ?Event
     {
-        $method = $operator->getMethod();
-        $values = $operator->getValues();
+        if ($this->statementEvents === null) {
+            return null;
+        }
 
-        switch ($method) {
-            // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                return ($value ?? 0) + ($values[0] ?? 1);
+        return $this->statementEvents[$stmt] ?? null;
+    }
 
-            case Operator::TYPE_DECREMENT:
-                return ($value ?? 0) - ($values[0] ?? 1);
+    protected function prepareStatement(string $sql, ?Event $event = null): DatabasePDOStatement|PDOStatementProxy|PDOStatement
+    {
+        if ($event !== null) {
+            $sql = $this->transformQuery($event, $sql);
+        }
 
-            case Operator::TYPE_MULTIPLY:
-                return ($value ?? 0) * ($values[0] ?? 1);
+        $statement = $this->getPDO()->prepare($sql);
+        if (! $statement instanceof DatabasePDOStatement && ! $statement instanceof PDOStatementProxy && ! $statement instanceof PDOStatement) {
+            throw new DatabaseException('Failed to prepare SQL statement');
+        }
 
-            case Operator::TYPE_DIVIDE:
-                $divisor = $values[0] ?? 1;
-                return (float)$divisor !== 0.0 ? ($value ?? 0) / $divisor : ($value ?? 0);
+        if ($event !== null) {
+            $this->statementEvents ??= new \WeakMap();
+            $this->statementEvents[$statement] = $event;
+        }
 
-            case Operator::TYPE_MODULO:
-                $divisor = $values[0] ?? 1;
-                return (float)$divisor !== 0.0 ? ($value ?? 0) % $divisor : ($value ?? 0);
+        return $statement;
+    }
 
-            case Operator::TYPE_POWER:
-                return pow($value ?? 0, $values[0] ?? 1);
+    protected function executeStatement(string $sql, Event $event): bool
+    {
+        return $this->execute($this->prepareStatement($sql, $event));
+    }
 
-                // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                return array_merge($value ?? [], $values);
+    private function transformQuery(Event $event, string $sql): string
+    {
+        foreach ($this->queryTransforms as $transform) {
+            $sql = $transform->transform($event, $sql);
+        }
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                return array_merge($values, $value ?? []);
+        return $sql;
+    }
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $arr = $value ?? [];
-                $index = $values[0] ?? 0;
-                $item = $values[1] ?? null;
-                array_splice($arr, $index, 0, [$item]);
-                return $arr;
+    /**
+     * Execute a single upsert batch using the query builder.
+     *
+     * Builds an INSERT ... ON CONFLICT/DUPLICATE KEY UPDATE statement via the
+     * query builder, handling spatial columns, shared-table tenant guards,
+     * increment attributes, and operator expressions.
+     *
+     * @param  string  $name  The filtered collection name
+     * @param  array<Change>  $changes  The changes to upsert
+     * @param  list<string>  $spatialAttributes  Spatial column names
+     * @param  string  $attribute  Increment attribute name (empty if none)
+     * @param  array<string, Operator>  $operators  Operator map keyed by attribute name
+     * @param  array<string, mixed>  $attributeDefaults  Attribute default values
+     * @param  bool  $hasOperators  Whether this batch contains operator expressions
+     *
+     * @throws DatabaseException
+     */
+    protected function executeUpsertBatch(
+        string $name,
+        array $changes,
+        array $spatialAttributes,
+        string $attribute,
+        array $operators,
+        array $attributeDefaults,
+        bool $hasOperators
+    ): void {
+        $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+
+        $spatialAttributes = $this->expandSpatialAttributes(
+            $spatialAttributes,
+            \array_map(static fn (Change $change) => $change->getNew(), $changes),
+        );
+
+        foreach ($spatialAttributes as $spatialCol) {
+            $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
+        }
 
-            case Operator::TYPE_ARRAY_REMOVE:
-                $arr = $value ?? [];
-                $toRemove = $values[0] ?? null;
-                if (is_array($toRemove)) {
-                    return array_values(array_diff($arr, $toRemove));
-                }
-                return array_values(array_diff($arr, [$toRemove]));
+        // Postgres requires an alias on the INSERT target for conflict resolution
+        if ($this->insertRequiresAlias()) {
+            $builder->insertAs('target');
+        }
+
+        // Collect all column names and build rows
+        $allColumnNames = [];
+        $documentsData = [];
 
-            case Operator::TYPE_ARRAY_UNIQUE:
-                return array_values(array_unique($value ?? []));
+        foreach ($changes as $change) {
+            $document = $change->getNew();
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                return array_values(array_intersect($value ?? [], $values));
+            if ($hasOperators) {
+                $extracted = Operator::extractOperators($document->getAttributes());
+                $currentRegularAttributes = $extracted['updates'];
+                $extractedOperators = $extracted['operators'];
 
-            case Operator::TYPE_ARRAY_DIFF:
-                return array_values(array_diff($value ?? [], $values));
+                // For new documents, apply operators to attribute defaults
+                if ($change->getOld()->isEmpty() && ! empty($extractedOperators)) {
+                    foreach ($extractedOperators as $operatorKey => $operator) {
+                        $default = $attributeDefaults[$operatorKey] ?? null;
+                        $currentRegularAttributes[$operatorKey] = $this->applyOperatorToValue($operator, $default);
+                    }
+                }
 
-            case Operator::TYPE_ARRAY_FILTER:
-                return $value ?? [];
+                $currentRegularAttributes[Storage::UID] = $document->getId();
+                $currentRegularAttributes[Storage::CREATED_AT] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
+                $currentRegularAttributes[Storage::UPDATED_AT] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
+            } else {
+                $currentRegularAttributes = $document->getAttributes();
+                $currentRegularAttributes[Storage::UID] = $document->getId();
+                $currentRegularAttributes[Storage::CREATED_AT] = $document->getCreatedAt() ? DateTime::setTimezone($document->getCreatedAt()) : null;
+                $currentRegularAttributes[Storage::UPDATED_AT] = $document->getUpdatedAt() ? DateTime::setTimezone($document->getUpdatedAt()) : null;
+            }
 
-                // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                return ($value ?? '') . ($values[0] ?? '');
+            $currentRegularAttributes[Storage::PERMISSIONS] = \json_encode($document->getPermissions());
 
-            case Operator::TYPE_STRING_REPLACE:
-                $search = $values[0] ?? '';
-                $replace = $values[1] ?? '';
-                return str_replace($search, $replace, $value ?? '');
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $currentRegularAttributes[Storage::VERSION] = $version;
+            }
 
-                // Boolean operators
-            case Operator::TYPE_TOGGLE:
-                return !($value ?? false);
+            if (! empty($document->getSequence())) {
+                $currentRegularAttributes[Storage::SEQUENCE] = $document->getSequence();
+            }
 
-                // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
-            case Operator::TYPE_DATE_SUB_DAYS:
-                // For NULL dates, operators return NULL
-                return $value;
+            if ($this->sharedTables) {
+                $currentRegularAttributes[Storage::TENANT] = $document->getTenant();
+            }
 
-            case Operator::TYPE_DATE_SET_NOW:
-                return DateTime::now();
+            foreach (\array_keys($currentRegularAttributes) as $colName) {
+                $allColumnNames[$colName] = true;
+            }
 
-            default:
-                return $value;
+            $documentsData[] = $currentRegularAttributes;
         }
-    }
 
-    /**
-     * Returns the current PDO object
-     * @return mixed
-     * @deprecated Use getDriver() instead
-     */
-    protected function getPDO(): mixed
-    {
-        return $this->pdo;
-    }
-
-    /**
-     * Returns the current PDO object
-     * @return mixed
-     */
-    public function getDriver(): mixed
-    {
-        return $this->pdo;
-    }
+        // Include operator column names in the column set
+        foreach (\array_keys($operators) as $colName) {
+            $allColumnNames[$colName] = true;
+        }
 
-    /**
-     * Get PDO Type
-     *
-     * @param mixed $value
-     * @return int
-     * @throws Exception
-     */
-    abstract protected function getPDOType(mixed $value): int;
+        $allColumnNames = \array_keys($allColumnNames);
+        \sort($allColumnNames);
+
+        // Hoist hot-loop guards: spatial set lookup is O(1) via array_flip, and
+        // IntegerBooleans support is a constant for the lifetime of the adapter.
+        $spatialMap = \array_fill_keys($spatialAttributes, true);
+        $intBools = $this->supports(Capability::IntegerBooleans);
+
+        // Build rows for the builder, applying JSON/boolean/spatial conversions
+        foreach ($documentsData as $docAttrs) {
+            $row = [];
+            foreach ($allColumnNames as $key) {
+                $value = $docAttrs[$key] ?? null;
+                if (isset($spatialMap[$key]) || $this->isSpatialWkt($value)) {
+                    $value = $this->encodeSpatialWriteValue($value);
+                } elseif (\is_array($value)) {
+                    $value = \json_encode($value);
+                }
+                if ($intBools && ! isset($spatialMap[$key])) {
+                    $value = (\is_bool($value)) ? (int) $value : $value;
+                }
+                $row[$key] = $value;
+            }
+            $builder->set($row);
+        }
 
-    /**
-     * Get the SQL function for random ordering
-     *
-     * @return string
-     */
-    abstract protected function getRandomOrder(): string;
+        // Determine conflict keys
+        $conflictKeys = $this->sharedTables ? [Storage::UID, Storage::TENANT] : [Storage::UID];
 
-    /**
-     * Returns default PDO configuration
-     *
-     * @return array<int, mixed>
-     */
-    public static function getPDOAttributes(): array
-    {
-        return [
-            \PDO::ATTR_TIMEOUT => 3, // Specifies the timeout duration in seconds. Takes a value of type int.
-            \PDO::ATTR_PERSISTENT => true, // Create a persistent connection
-            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC, // Fetch a result row as an associative array.
-            \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION, // PDO will throw a PDOException on errors
-            \PDO::ATTR_EMULATE_PREPARES => true, // Emulate prepared statements
-            \PDO::ATTR_STRINGIFY_FETCHES => true // Returns all fetched data as Strings
-        ];
-    }
+        // Determine which columns to update on conflict
+        $skipColumns = [Storage::UID, Storage::SEQUENCE, Storage::CREATED_AT, Storage::TENANT];
 
-    public function getHostname(): string
-    {
-        try {
-            return $this->pdo->getHostname();
-        } catch (\Throwable) {
-            return '';
+        if (! empty($attribute)) {
+            // Increment mode: only update the increment column and _updatedAt
+            $updateColumns = [$this->filter($attribute), Storage::UPDATED_AT];
+        } else {
+            // Normal mode: update all columns except the skip set
+            $updateColumns = \array_values(\array_filter(
+                $allColumnNames,
+                fn ($c) => ! \in_array($c, $skipColumns)
+            ));
         }
-    }
-
-    /**
-     * @return int
-     */
-    public function getMaxVarcharLength(): int
-    {
-        return 16381; // Floor value for Postgres:16383 | MySQL:16381 | MariaDB:16382
-    }
 
-    /**
-     * Size of POINT spatial type
-     *
-     * @return int
-    */
-    abstract protected function getMaxPointSize(): int;
-    /**
-     * @return string
-     */
-    public function getIdAttributeType(): string
-    {
-        return Database::VAR_INTEGER;
-    }
+        $builder->onConflict($conflictKeys, $updateColumns);
 
-    /**
-     * @return int
-     */
-    public function getMaxIndexLength(): int
-    {
-        /**
-         * $tenant int = 1
-         */
-        return $this->sharedTables ? 767 : 768;
+        // Apply conflict-resolution expressions
+        // Column names passed to conflictSetRaw() must match the names in onConflict().
+        // The expression-generating methods handle their own quoting/filtering internally.
+        if (! empty($attribute)) {
+            // Increment attribute
+            $filteredAttr = $this->filter($attribute);
+            if ($this->sharedTables) {
+                $builder->conflictSetRaw($filteredAttr, $this->getConflictTenantIncrementExpression($filteredAttr));
+                $builder->conflictSetRaw(Storage::UPDATED_AT, $this->getConflictTenantExpression(Storage::UPDATED_AT));
+            } else {
+                $builder->conflictSetRaw($filteredAttr, $this->getConflictIncrementExpression($filteredAttr));
+            }
+        } elseif (! empty($operators)) {
+            // Operator columns
+            foreach ($allColumnNames as $colName) {
+                if (\in_array($colName, $skipColumns)) {
+                    continue;
+                }
+                if (isset($operators[$colName])) {
+                    $filteredCol = $this->filter($colName);
+                    $opResult = $this->getOperatorUpsertExpression($filteredCol, $operators[$colName]);
+                    $builder->conflictSetRaw($colName, $opResult['expression'], $opResult['bindings']);
+                } elseif ($this->sharedTables) {
+                    $builder->conflictSetRaw($colName, $this->getConflictTenantExpression($colName));
+                }
+            }
+        } elseif ($this->sharedTables) {
+            // Shared tables without operators or increment: tenant-guard all update columns
+            foreach ($updateColumns as $col) {
+                $builder->conflictSetRaw($col, $this->getConflictTenantExpression($col));
+            }
+        }
+
+        if (! $builder instanceof UpsertFeature) {
+            throw new DatabaseException('Upserts are not supported on this dialect');
+        }
+
+        $result = $builder->upsert();
+        $stmt = $this->executeResult($result, Event::DocumentsUpsert);
+        $this->execute($stmt);
+        $stmt->closeCursor();
     }
 
     /**
-     * @return int
+     * Map attribute selections to database column names.
+     *
+     * Converts user-facing attribute names (like $id, $sequence) to internal
+     * database column names (like _uid, _id) and ensures internal columns
+     * are always included.
+     *
+     * @param  array<string>  $selections
+     * @param  array<string>  $joinAliases
      */
-    public function getMaxUIDLength(): int
-    {
-        return 36;
+    private function applySelectionProjection(
+        SQLBuilder $builder,
+        array $selections,
+        bool $includeInternal = true,
+        array $joinAliases = [],
+    ): void {
+        $mapped = $this->mapSelectionsToColumns($selections, $includeInternal, $joinAliases);
+        $simple = [];
+        foreach ($mapped as $column) {
+            if (\str_contains($column, ' AS ')) {
+                $builder->selectRaw($column);
+            } else {
+                $simple[] = $column;
+            }
+        }
+        if ($simple !== []) {
+            $builder->select($simple);
+        }
     }
 
     /**
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param ?string $forCollection Filtered collection id (for FTS5 routing).
-     * @return string
-     * @throws Exception
+     * @param  array<BaseQuery>  $queries
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
      */
-    abstract protected function getSQLCondition(Query $query, array &$binds, ?string $forCollection = null): string;
+    private function remapDottedQueryAttributes(array $queries, array $joinTablePrefixes, Document $collection): void
+    {
+        $aliasSet = \array_fill_keys(\array_column($joinTablePrefixes, 'alias'), true);
+        $aliasSet[Query::DEFAULT_ALIAS] = true;
+        $mainAttributes = [];
+        /** @var array<Document> $collectionAttrs */
+        $collectionAttrs = $collection->getAttribute('attributes', []);
+        foreach ($collectionAttrs as $attribute) {
+            $mainAttributes[$attribute->getId()] = true;
+        }
+
+        foreach ($queries as $query) {
+            $this->remapDottedQuery($query, $aliasSet, $mainAttributes);
+        }
+    }
 
     /**
-     * @param array<Query> $queries
-     * @param array<string, mixed> $binds
-     * @param string $separator
-     * @param ?string $forCollection See {@see getSQLCondition}.
-     * @return string
-     * @throws Exception
+     * @param  array<string, true>  $aliasSet
+     * @param  array<string, true>  $mainAttributes
      */
-    public function getSQLConditions(array $queries, array &$binds, string $separator = 'AND', ?string $forCollection = null): string
+    private function remapDottedQuery(BaseQuery $query, array $aliasSet, array $mainAttributes): void
     {
-        $conditions = [];
-        foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                continue;
+        $method = $query->getMethod();
+        if ($method === Method::Select) {
+            return;
+        }
+
+        if ($method->isJoin()) {
+            if ($query->isNestedJoin()) {
+                foreach ($query->getJoinOnQueries() as $onQuery) {
+                    if ($onQuery->getMethod() === Method::On) {
+                        continue;
+                    }
+                    $this->remapDottedQuery($onQuery, $aliasSet, $mainAttributes);
+                }
             }
 
-            if ($query->isNested()) {
-                $conditions[] = $this->getSQLConditions($query->getValues(), $binds, $query->getMethod(), $forCollection);
-            } else {
-                $conditions[] = $this->getSQLCondition($query, $binds, $forCollection);
+            return;
+        }
+
+        if ($query->isNested()) {
+            foreach ($query->getValues() as $child) {
+                if ($child instanceof BaseQuery) {
+                    $this->remapDottedQuery($child, $aliasSet, $mainAttributes);
+                }
             }
+
+            return;
         }
 
-        $tmp = implode(' ' . $separator . ' ', $conditions);
-        return empty($tmp) ? '' : '(' . $tmp . ')';
-    }
+        if ($method === Method::GroupBy) {
+            $values = $query->getValues();
+            $changed = false;
+            foreach ($values as $i => $column) {
+                if (! \is_string($column) || ! \str_contains($column, '.')) {
+                    continue;
+                }
+                $values[$i] = $this->qualifyDottedAttribute($column, $aliasSet, $mainAttributes);
+                $changed = true;
+            }
+            if ($changed) {
+                $query->setValues($values);
+            }
 
-    /**
-     * @return string
-     */
-    public function getLikeOperator(): string
-    {
-        return 'LIKE';
+            return;
+        }
+
+        $attribute = $query->getAttribute();
+        if ($attribute === '' || $attribute === '*' || ! \str_contains($attribute, '.')) {
+            return;
+        }
+
+        $query->setAttribute($this->qualifyDottedAttribute($attribute, $aliasSet, $mainAttributes));
     }
 
     /**
-     * @return string
+     * @param  array<string, true>  $aliasSet
+     * @param  array<string, true>  $mainAttributes
      */
-    public function getRegexOperator(): string
+    private function qualifyDottedAttribute(string $attribute, array $aliasSet, array $mainAttributes): string
     {
-        return 'REGEXP';
-    }
+        if (isset($mainAttributes[$attribute])) {
+            return $this->filter($this->getInternalKeyForAttribute($attribute));
+        }
 
-    public function getInternalIndexesKeys(): array
-    {
-        return [];
-    }
+        $dot = \strpos($attribute, '.');
+        if ($dot === false) {
+            return $this->filter($this->getInternalKeyForAttribute($attribute));
+        }
 
-    public function getSchemaAttributes(string $collection): array
-    {
-        return [];
-    }
+        $prefix = \substr($attribute, 0, $dot);
+        if (isset($aliasSet[$prefix])) {
+            $name = \substr($attribute, $dot + 1);
 
-    public function getSchemaIndexes(string $collection): array
-    {
-        return [];
+            return $this->filter($prefix).'.'.$this->filter($this->getInternalKeyForAttribute($name));
+        }
+
+        return $attribute;
     }
 
-    public function getSupportForSchemaIndexes(): bool
+    /**
+     * @param  array<string>  $selections
+     * @param  array<string>  $joinAliases
+     * @return array<string>
+     */
+    protected function mapSelectionsToColumns(array $selections, bool $includeInternal = true, array $joinAliases = []): array
     {
-        return false;
-    }
+        $internalKeys = [
+            Document::ID,
+            Document::SEQUENCE,
+            Document::PERMISSIONS,
+            Document::CREATED_AT,
+            Document::UPDATED_AT,
+        ];
 
-    public function getTenantQuery(
-        string $collection,
-        string $alias = '',
-        int $tenantCount = 0,
-        string $condition = 'AND'
-    ): string {
-        if (!$this->sharedTables) {
-            return '';
+        $explicitInternals = [];
+        foreach ($selections as $selection) {
+            if (\in_array($selection, $internalKeys, true)) {
+                $explicitInternals[] = $selection;
+            }
         }
 
-        $dot = '';
-        if ($alias !== '') {
-            $dot = '.';
-            $alias = $this->quote($alias);
-        }
+        $selections = \array_values(\array_diff($selections, [...$internalKeys, Document::COLLECTION]));
 
-        $bindings = [];
-        if ($tenantCount === 0) {
-            $bindings[] = ':_tenant';
+        if ($includeInternal) {
+            foreach ($internalKeys as $internalKey) {
+                $selections[] = $this->getInternalKeyForAttribute($internalKey);
+            }
         } else {
-            for ($index = 0; $index < $tenantCount; $index++) {
-                $bindings[] = ":_tenant_{$index}";
+            foreach (\array_values(\array_unique($explicitInternals)) as $internalKey) {
+                $selections[] = $this->getInternalKeyForAttribute($internalKey);
             }
         }
-        $bindings = \implode(',', $bindings);
 
-        $orIsNull = '';
-        if ($collection === Database::METADATA) {
-            $orIsNull = " OR {$alias}{$dot}_tenant IS NULL";
+        $aliasSet = \array_fill_keys($joinAliases, true);
+        $quote = $this->getIdentifierQuoteChar();
+        $columns = [];
+        foreach ($selections as $selection) {
+            $dot = \strpos($selection, '.');
+            if ($dot !== false) {
+                $prefix = \substr($selection, 0, $dot);
+                if (isset($aliasSet[$prefix])) {
+                    $name = \substr($selection, $dot + 1);
+                    $internal = $this->filter($this->getInternalKeyForAttribute($name));
+                    $qualified = $quote.$this->filter($prefix).$quote.'.'.$quote.$internal.$quote;
+                    $output = $prefix.'.'.$internal;
+                    $columns[] = $qualified.' AS '.$quote.$output.$quote;
+
+                    continue;
+                }
+            }
+            $columns[] = $this->filter($selection);
         }
 
-        return "{$condition} ({$alias}{$dot}_tenant IN ({$bindings}) {$orIsNull})";
+        return $columns;
     }
 
     /**
-     * Get the SQL projection given the selected attributes
-     *
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
-     * @throws Exception
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
+     * @return list<string>
      */
-    protected function getAttributeProjection(array $selections, string $prefix): mixed
+    private function starProjection(array $joinTablePrefixes, string $alias): array
     {
-        if (empty($selections) || \in_array('*', $selections)) {
-            return "{$this->quote($prefix)}.*";
+        $columns = [];
+        foreach ($joinTablePrefixes as $join) {
+            $columns[] = $this->filter($join['alias']).'.*';
         }
+        $columns[] = $this->filter($alias).'.*';
 
-        // Handle specific selections with spatial conversion where needed
-        $internalKeys = [
-            '$id',
-            '$sequence',
-            '$permissions',
-            '$createdAt',
-            '$updatedAt',
-        ];
+        return $columns;
+    }
 
-        $hasDeletedAt = \in_array('$deletedAt', $selections);
+    /**
+     * Map Database type constants to Schema Table column definitions.
+     *
+     * @throws DatabaseException
+     */
+    protected function addTableColumn(
+        Table $table,
+        string $id,
+        ColumnType $type,
+        int $size,
+        bool $signed = true,
+        bool $array = false,
+        bool $required = false
+    ): Column {
+        $filteredId = $this->filter($id);
+
+        if (\in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon])) {
+            $col = match ($type) {
+                ColumnType::Point => $table->point($filteredId, Database::DEFAULT_SRID),
+                ColumnType::Linestring => $table->linestring($filteredId, Database::DEFAULT_SRID),
+                ColumnType::Polygon => $table->polygon($filteredId, Database::DEFAULT_SRID),
+            };
+            if (! $required) {
+                $col->nullable();
+            }
 
-        $selections = \array_diff($selections, [...$internalKeys, '$deletedAt', '$collection']);
+            return $col;
+        }
 
-        foreach ($internalKeys as $internalKey) {
-            $selections[] = $this->getInternalKeyForAttribute($internalKey);
+        if ($array) {
+            // Arrays use JSON type and are nullable by default
+            return $table->json($filteredId)->nullable();
         }
 
-        if ($hasDeletedAt) {
-            $selections[] = $this->getInternalKeyForAttribute('$deletedAt');
+        $col = match ($type) {
+            ColumnType::String => match (true) {
+                $size > 16777215 => $table->longText($filteredId),
+                $size > 65535 => $table->mediumText($filteredId),
+                $size > $this->getMaxVarcharLength() => $table->text($filteredId),
+                $size <= 0 => $table->text($filteredId),
+                default => $table->string($filteredId, $size),
+            },
+            ColumnType::Integer => $size >= 8
+                ? $table->bigInteger($filteredId)
+                : $table->integer($filteredId),
+            ColumnType::BigInteger => $table->bigInteger($filteredId),
+            ColumnType::BigSerial => $this->addBigSerialColumn($table, $filteredId),
+            ColumnType::Float, ColumnType::Double => $table->float($filteredId),
+            ColumnType::Boolean => $table->boolean($filteredId),
+            ColumnType::Datetime => $table->datetime($filteredId, 3),
+            ColumnType::Relationship => $table->string($filteredId, 255),
+            ColumnType::Id => $table->bigInteger($filteredId),
+            ColumnType::Varchar => $table->string($filteredId, $size),
+            ColumnType::Text => $table->text($filteredId),
+            ColumnType::MediumText => $table->mediumText($filteredId),
+            ColumnType::LongText => $table->longText($filteredId),
+            ColumnType::Object => $table->json($filteredId),
+            ColumnType::Vector => $this->addVectorColumn($table, $filteredId, $size),
+            default => throw new DatabaseException('Unknown type: '.$type->value),
+        };
+
+        // Apply unsigned for types that support it
+        if (! $signed && \in_array($type, [ColumnType::Integer, ColumnType::BigInteger, ColumnType::BigSerial, ColumnType::Float, ColumnType::Double], true)) {
+            $col->unsigned();
         }
 
-        $projections = [];
-        foreach ($selections as $selection) {
-            $filteredSelection = $this->filter($selection);
-            $quotedSelection = $this->quote($filteredSelection);
-            $projections[] = "{$this->quote($prefix)}.{$quotedSelection}";
+        // Id type is always unsigned
+        if ($type === ColumnType::Id) {
+            $col->unsigned();
         }
 
-        return \implode(',', $projections);
+        // Non-spatial columns are nullable by default to match existing behavior
+        $col->nullable();
+
+        return $col;
     }
 
-    protected function getInternalKeyForAttribute(string $attribute): string
+    private function addBigSerialColumn(Table $table, string $name): Column
     {
-        return match ($attribute) {
-            '$id' => '_uid',
-            '$sequence' => '_id',
-            '$collection' => '_collection',
-            '$tenant' => '_tenant',
-            '$createdAt' => '_createdAt',
-            '$updatedAt' => '_updatedAt',
-            '$deletedAt' => '_deletedAt',
-            '$permissions' => '_permissions',
-            default => $attribute
-        };
+        if (! $table instanceof MySQLTable && ! $table instanceof PostgreSQLTable) {
+            throw new DatabaseException('Serial columns are not supported on this dialect');
+        }
+
+        return $table->bigSerial($name);
     }
 
-    protected function escapeWildcards(string $value): string
+    private function addVectorColumn(Table $table, string $name, int $size): Column
     {
-        $wildcards = ['%', '_', '[', ']', '^', '-', '.', '*', '+', '?', '(', ')', '{', '}', '|'];
-
-        foreach ($wildcards as $wildcard) {
-            $value = \str_replace($wildcard, "\\$wildcard", $value);
+        if (! $table instanceof PostgreSQLTable) {
+            throw new DatabaseException('Vector columns are only supported on PostgreSQL');
         }
 
-        return $value;
+        return $table->vector($name, $size);
     }
 
-    protected function processException(PDOException $e): \Exception
+    /**
+     * @param  array<BaseQuery>  $queries
+     */
+    private function queriesHaveJoins(array $queries): bool
     {
-        return $e;
+        foreach ($queries as $query) {
+            if ($query->getMethod()->isJoin()) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     /**
-     * @param mixed $stmt
-     * @return bool
+     * @param  array<BaseQuery>  $queries
+     * @return list<array{table: string, alias: string}>
      */
-    protected function execute(mixed $stmt): bool
+    private function remapJoinQueries(array &$queries): array
     {
-        return $stmt->execute();
+        $joinTablePrefixes = [];
+        $joinIndex = 0;
+        $alias = Query::DEFAULT_ALIAS;
+
+        foreach ($queries as $query) {
+            if (! $query->getMethod()->isJoin()) {
+                continue;
+            }
+
+            $joinTable = $query->getAttribute();
+            $resolvedTable = $this->getSQLTableRaw($this->filter($joinTable));
+            $query->setAttribute($resolvedTable);
+
+            $method = $query->getMethod();
+            $joinAlias = $this->sanitizeJoinAlias($query->getJoinAlias());
+            if ($joinAlias === '') {
+                $joinAlias = 'j'.$joinIndex;
+            }
+            $joinIndex++;
+
+            if ($method === Method::CrossJoin || $method === Method::NaturalJoin) {
+                $query->setValues([$joinAlias]);
+            } elseif ($query->isNestedJoin()) {
+                $query->setValues($this->remapNestedJoinValues($query, $alias, $joinAlias));
+            } else {
+                $values = $query->getValues();
+                if (\count($values) >= 3) {
+                    $left = $values[0] ?? null;
+                    $right = $values[2] ?? null;
+                    if (! \is_string($left) || ! \is_string($right)) {
+                        throw new QueryException('Join columns must be strings');
+                    }
+                    $values[0] = $this->qualifyJoinColumn($left, $alias);
+                    $values[2] = $this->qualifyJoinColumn($right, $joinAlias);
+                    $values[3] = $joinAlias;
+                    $query->setValues($values);
+                }
+            }
+
+            $joinTablePrefixes[] = ['table' => $joinTable, 'alias' => $joinAlias];
+        }
+
+        return $joinTablePrefixes;
     }
 
     /**
-     * Create Documents in batches
-     *
-     * @param Document $collection
-     * @param array<Document> $documents
-     *
-     * @return array<Document>
-     *
-     * @throws DuplicateException
-     * @throws \Throwable
+     * @return list<mixed>
      */
-    public function createDocuments(Document $collection, array $documents): array
+    private function remapNestedJoinValues(BaseQuery $query, string $mainAlias, string $joinAlias): array
     {
-        if (empty($documents)) {
-            return $documents;
+        $values = [$joinAlias];
+        foreach ($query->getJoinOnQueries() as $onQuery) {
+            $values[] = $this->remapNestedJoinOnQuery($onQuery, $mainAlias, $joinAlias);
         }
 
-        $spatialAttributes = $this->getSpatialAttributes($collection);
-        $collection = $collection->getId();
-        try {
-            $name = $this->filter($collection);
+        return $values;
+    }
 
-            $attributeKeys = Database::INTERNAL_ATTRIBUTE_KEYS;
+    private function remapNestedJoinOnQuery(BaseQuery $onQuery, string $mainAlias, string $joinAlias): BaseQuery
+    {
+        if ($onQuery->getMethod() !== Method::On) {
+            return $onQuery;
+        }
 
-            $hasSequence = null;
-            foreach ($documents as $document) {
-                $attributes = $document->getAttributes();
-                $attributeKeys = [...$attributeKeys, ...\array_keys($attributes)];
+        $values = $onQuery->getValues();
+        $left = $values[0] ?? null;
+        $right = $values[2] ?? null;
+        if (! \is_string($left) || $left === '' || ! \is_string($right) || $right === '') {
+            throw new QueryException('Join ON requires left and right columns');
+        }
 
-                if ($hasSequence === null) {
-                    $hasSequence = !empty($document->getSequence());
-                } elseif ($hasSequence == empty($document->getSequence())) {
-                    throw new DatabaseException('All documents must have an sequence if one is set');
-                }
-            }
+        $values[0] = $this->qualifyJoinColumn($left, $mainAlias);
+        $values[2] = $this->qualifyJoinColumn($right, $joinAlias);
+        $onQuery->setValues($values);
 
-            $attributeKeys = array_unique($attributeKeys);
+        return $onQuery;
+    }
 
-            if ($hasSequence) {
-                $attributeKeys[] = '_id';
-            }
+    /**
+     * @param  array<BaseQuery>  $queries
+     */
+    private function needsFullOuterJoinEmulation(SQLBuilder $builder, array $queries): bool
+    {
+        if ($builder instanceof FullOuterJoinsFeature) {
+            return false;
+        }
 
-            if ($this->sharedTables) {
-                $attributeKeys[] = '_tenant';
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::FullOuterJoin) {
+                return true;
             }
+        }
 
-            $columns = [];
-            foreach ($attributeKeys as $key => $attribute) {
-                $columns[$key] = $this->quote($this->filter($attribute));
-            }
+        return false;
+    }
 
-            $columns = '(' . \implode(', ', $columns) . ')';
+    /**
+     * @param  array<BaseQuery>  $queries
+     * @return array<BaseQuery>
+     */
+    private function rewriteFullOuterJoins(array $queries, Method $replacement): array
+    {
+        $rewritten = [];
+        foreach ($queries as $query) {
+            $clone = clone $query;
+            if ($clone->getMethod() === Method::FullOuterJoin) {
+                $clone->setMethod($replacement);
+            }
+            $rewritten[] = $clone;
+        }
 
-            $bindIndex = 0;
-            $batchKeys = [];
-            $bindValues = [];
-            $permissions = [];
-            $bindValuesPermissions = [];
+        return $rewritten;
+    }
 
-            foreach ($documents as $index => $document) {
-                $attributes = $document->getAttributes();
-                $attributes['_uid'] = $document->getId();
-                $attributes['_createdAt'] = $document->getCreatedAt();
-                $attributes['_updatedAt'] = $document->getUpdatedAt();
-                $attributes['_permissions'] = \json_encode($document->getPermissions());
+    /**
+     * @param  array<BaseQuery>  $queries
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
+     * @param  array<Query>  $adapterFilterQueries
+     * @param  array<string>  $roles
+     */
+    private function configureFindBuilder(
+        SQLBuilder $builder,
+        Document $collection,
+        array $queries,
+        array $joinTablePrefixes,
+        bool $hasAggregation,
+        bool $hasDistinct,
+        array $adapterFilterQueries,
+        string $name,
+        string $alias,
+        array $roles,
+        PermissionType $forPermission,
+        bool $preservingOuter,
+    ): bool {
+        $hasSelectionProjection = false;
+        if (! $hasAggregation) {
+            $selections = [];
+            foreach ($queries as $query) {
+                if ($query->getMethod() === Method::Select) {
+                    foreach ($query->getValues() as $value) {
+                        /** @var string $value */
+                        $selections[] = $value;
+                    }
+                }
+            }
+            if (! empty($selections) && ! \in_array('*', $selections)) {
+                $this->applySelectionProjection(
+                    $builder,
+                    $selections,
+                    includeInternal: ! $hasDistinct,
+                    joinAliases: \array_column($joinTablePrefixes, 'alias'),
+                );
+                $hasSelectionProjection = true;
+            } elseif (! empty($joinTablePrefixes)) {
+                $builder->select($this->starProjection($joinTablePrefixes, $alias));
+            }
+        }
 
-                if (!empty($document->getSequence())) {
-                    $attributes['_id'] = $document->getSequence();
+        if ($hasAggregation && ! empty($joinTablePrefixes)) {
+            /** @var array<Document> $collectionAttrs */
+            $collectionAttrs = $collection->getAttribute('attributes', []);
+            $mainAttributeSet = [];
+            foreach ($collectionAttrs as $attr) {
+                $mainAttributeSet[$attr->getId()] = true;
+            }
+            $defaultJoinPrefix = $joinTablePrefixes[0]['alias'];
+
+            foreach ($queries as $query) {
+                if ($query->getMethod()->isAggregate()) {
+                    $attr = $query->getAttribute();
+                    if ($attr !== '*' && $attr !== '' && ! \str_contains($attr, '.') && ! isset($mainAttributeSet[$attr])) {
+                        $internalAttr = $this->getInternalKeyForAttribute($attr);
+                        $query->setAttribute($defaultJoinPrefix.'.'.$internalAttr);
+                    }
+                } elseif ($query->getMethod() === Method::GroupBy) {
+                    $values = $query->getValues();
+                    $qualified = false;
+                    foreach ($values as $i => $col) {
+                        if (\is_string($col) && ! \str_contains($col, '.') && ! isset($mainAttributeSet[$col])) {
+                            $internalCol = $this->getInternalKeyForAttribute($col);
+                            $values[$i] = $defaultJoinPrefix.'.'.$internalCol;
+                            $qualified = true;
+                        }
+                    }
+                    if ($qualified) {
+                        $query->setValues($values);
+                    }
                 }
+            }
+        }
 
-                if ($this->sharedTables) {
-                    $attributes['_tenant'] = $document->getTenant();
+        if ($hasAggregation) {
+            foreach ($queries as $query) {
+                if ($query->getMethod() === Method::GroupBy) {
+                    /** @var array<string> $groupCols */
+                    $groupCols = $query->getValues();
+                    $builder->select(\array_map(
+                        fn (string $col) => \str_contains($col, '.') ? $col : $this->filter($this->getInternalKeyForAttribute($col)),
+                        $groupCols
+                    ));
                 }
+            }
+        }
 
-                $bindKeys = [];
+        $this->applyFindFilters(
+            $builder,
+            $collection,
+            $queries,
+            $joinTablePrefixes,
+            $adapterFilterQueries,
+            $name,
+            $alias,
+            $roles,
+            $forPermission,
+            $preservingOuter,
+        );
+
+        return $hasSelectionProjection;
+    }
 
-                foreach ($attributeKeys as $key) {
-                    $value = $attributes[$key] ?? null;
-                    if (\is_array($value)) {
-                        $value = \json_encode($value);
-                    }
-                    if (in_array($key, $spatialAttributes)) {
-                        $bindKey = 'key_' . $bindIndex;
-                        $bindKeys[] = $this->getSpatialGeomFromText(":" . $bindKey);
-                    } else {
-                        if ($this->getSupportForIntegerBooleans()) {
-                            $value = (\is_bool($value)) ? (int)$value : $value;
-                        }
-                        $bindKey = 'key_' . $bindIndex;
-                        $bindKeys[] = ':' . $bindKey;
-                    }
-                    $bindValues[$bindKey] = $value;
-                    $bindIndex++;
+    /**
+     * @param  array<BaseQuery>  $queries
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
+     * @param  array<Query>  $adapterFilterQueries
+     * @param  array<string>  $roles
+     */
+    private function applyFindFilters(
+        SQLBuilder $builder,
+        Document $collection,
+        array $queries,
+        array $joinTablePrefixes,
+        array $adapterFilterQueries,
+        string $name,
+        string $alias,
+        array $roles,
+        PermissionType $forPermission,
+        bool $preservingOuter,
+    ): void {
+        $this->remapDottedQueryAttributes($queries, $joinTablePrefixes, $collection);
+        $builder->filter($queries);
+
+        foreach ($adapterFilterQueries as $query) {
+            $compiled = $this->compileAdapterFilter($query, $name, $alias);
+            if ($compiled !== null) {
+                $builder->whereRaw($compiled['expression'], $compiled['bindings']);
+            }
+        }
+
+        if ($this->authorization->getStatus()) {
+            $hasJoins = ! empty($joinTablePrefixes);
+            if ((bool) $collection->getAttribute('documentSecurity', false)) {
+                $docCol = $hasJoins ? $alias.'.'.Storage::UID : Storage::UID;
+                $permissionHook = $this->newPermissionHook($name, $roles, $forPermission->value, $docCol);
+                if ($preservingOuter) {
+                    $permissionHook = new PermissionAllowNullUid(
+                        $permissionHook,
+                        $docCol,
+                        $this->getIdentifierQuoteChar(),
+                    );
                 }
+                $builder->addHook($permissionHook);
+            }
 
-                $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
+            $joinDocumentSecurity = $collection->getAttribute('joinDocumentSecurity', []);
+            /** @var array<string, mixed> $joinDocumentSecurity */
+            $joinDocumentSecurity = \is_array($joinDocumentSecurity) ? $joinDocumentSecurity : [];
 
-                foreach (Database::PERMISSIONS as $type) {
-                    foreach ($document->getPermissionsByType($type) as $permission) {
-                        $tenantBind = $this->sharedTables ? ", :_tenant_{$index}" : '';
-                        $permission = \str_replace('"', '', $permission);
-                        $permission = "('{$type}', '{$permission}', :_uid_{$index} {$tenantBind})";
-                        $permissions[] = $permission;
-                        $bindValuesPermissions[":_uid_{$index}"] = $document->getId();
-                        if ($this->sharedTables) {
-                            $bindValuesPermissions[":_tenant_{$index}"] = $document->getTenant();
-                        }
-                    }
+            foreach ($joinTablePrefixes as $join) {
+                if ($this->joinDocumentSecurityEnabled($joinDocumentSecurity, $join['table']) === false) {
+                    continue;
                 }
+
+                $builder->addHook(new PermissionJoinFilter(
+                    $this->newPermissionHook(
+                        $this->filter($join['table']),
+                        $roles,
+                        $forPermission->value,
+                        $join['alias'].'.'.Storage::UID
+                    ),
+                    $join['alias'],
+                    $this->getIdentifierQuoteChar(),
+                ));
             }
+        }
+    }
 
-            $batchKeys = \implode(', ', $batchKeys);
+    /**
+     * @param  array<string, mixed>  $joinDocumentSecurity
+     */
+    private function joinDocumentSecurityEnabled(array $joinDocumentSecurity, string $table): bool
+    {
+        foreach ($this->joinDocumentSecurityLookupKeys($table) as $key) {
+            if (\array_key_exists($key, $joinDocumentSecurity)) {
+                return (bool) $joinDocumentSecurity[$key];
+            }
+        }
 
-            $stmt = $this->getPDO()->prepare("
-                {$this->getInsertKeyword()} {$this->getSQLTable($name)} {$columns}
-                VALUES {$batchKeys}
-                {$this->getInsertSuffix($name)}
-            ");
+        if ($joinDocumentSecurity === []) {
+            return true;
+        }
 
-            foreach ($bindValues as $key => $value) {
-                $stmt->bindValue($key, $value, $this->getPDOType($value));
+        $candidates = $this->joinDocumentSecurityLookupKeys($table);
+        foreach ($joinDocumentSecurity as $key => $enabled) {
+            $key = (string) $key;
+            if ($key === '') {
+                continue;
             }
 
-            $this->execute($stmt);
-
-            if (!empty($permissions)) {
-                $tenantColumn = $this->sharedTables ? ', _tenant' : '';
-                $permissions = \implode(', ', $permissions);
+            if (\array_intersect($candidates, $this->joinDocumentSecurityLookupKeys($key)) !== []) {
+                return (bool) $enabled;
+            }
+        }
 
-                $sqlPermissions = "
-                    {$this->getInsertKeyword()} {$this->getSQLTable($name . '_perms')} (_type, _permission, _document {$tenantColumn})
-                    VALUES {$permissions}
-                    {$this->getInsertPermissionsSuffix()}
-                ";
+        return true;
+    }
 
-                $stmtPermissions = $this->getPDO()->prepare($sqlPermissions);
+    /**
+     * @return list<string>
+     */
+    private function joinDocumentSecurityLookupKeys(string $table): array
+    {
+        $filtered = $this->filter($table);
+        $keys = [$table, $filtered];
+        $qualified = $this->getSQLTableRaw($filtered);
+        $keys[] = $qualified;
+
+        $dot = \strrpos($qualified, '.');
+        if ($dot !== false) {
+            $keys[] = \substr($qualified, $dot + 1);
+        }
 
-                foreach ($bindValuesPermissions as $key => $value) {
-                    $stmtPermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
+        return \array_values(\array_unique($keys));
+    }
 
-                $this->execute($stmtPermissions);
+    /**
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  list<array{table: string, alias: string}>  $joinTablePrefixes
+     */
+    private function applyFullOuterJoinOrderProjection(
+        SQLBuilder $builder,
+        string $alias,
+        array $orderAttributes,
+        array $orderTypes,
+        bool $hasSelectionProjection,
+        array $joinTablePrefixes = [],
+    ): void {
+        $hasOrderColumns = false;
+        foreach (\array_keys($orderAttributes) as $i) {
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+            if ($orderType !== OrderDirection::Random) {
+                $hasOrderColumns = true;
+                break;
             }
+        }
 
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        if (! $hasOrderColumns) {
+            return;
         }
 
-        return $documents;
+        if (! $hasSelectionProjection) {
+            $builder->select(
+                empty($joinTablePrefixes)
+                    ? ['*']
+                    : $this->starProjection($joinTablePrefixes, $alias)
+            );
+        }
+
+        $quote = $this->getIdentifierQuoteChar();
+        $joinAliases = \array_column($joinTablePrefixes, 'alias');
+        foreach ($orderAttributes as $i => $attribute) {
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+            if ($orderType === OrderDirection::Random) {
+                continue;
+            }
+
+            $qualified = $this->qualifyOrderAttribute($attribute, $joinAliases);
+            $dot = \strpos($qualified, '.');
+            if ($dot !== false) {
+                $prefix = \substr($qualified, 0, $dot);
+                $column = \substr($qualified, $dot + 1);
+                $expression = $quote.$prefix.$quote.'.'.$quote.$column.$quote;
+            } else {
+                $expression = $quote.$alias.$quote.'.'.$quote.$qualified.$quote;
+            }
+
+            $output = self::FOJ_ORDER_ALIAS_PREFIX.$i;
+            $builder->selectRaw($expression.' AS '.$quote.$output.$quote);
+        }
     }
 
     /**
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Change> $changes
-     * @return array<Document>
-     * @throws DatabaseException
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
+     * @param  callable(string): string  $resolveInternalKey
      */
-    public function upsertDocuments(
-        Document $collection,
-        string $attribute,
-        array $changes
-    ): array {
-        if (empty($changes)) {
-            return $changes;
+    private function applyFindCursor(
+        SQLBuilder $builder,
+        array $orderAttributes,
+        array $orderTypes,
+        array $cursor,
+        CursorDirection $cursorDirection,
+        callable $resolveInternalKey,
+    ): void {
+        if ($cursor === []) {
+            return;
         }
-        try {
-            $spatialAttributes = $this->getSpatialAttributes($collection);
 
-            $attributeDefaults = [];
-            foreach ($collection->getAttribute('attributes', []) as $attr) {
-                $attributeDefaults[$attr['$id']] = $attr['default'] ?? null;
+        $cursorConditions = [];
+
+        foreach ($orderAttributes as $i => $originalAttribute) {
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+            if ($orderType === OrderDirection::Random) {
+                continue;
             }
 
-            $collection = $collection->getId();
-            $name = $this->filter($collection);
+            $direction = $orderType;
 
-            $hasOperators = false;
-            $firstChange = $changes[0];
-            $firstDoc = $firstChange->getNew();
-            $firstExtracted = Operator::extractOperators($firstDoc->getAttributes());
+            if ($cursorDirection === CursorDirection::Before) {
+                $direction = ($direction === OrderDirection::Asc)
+                    ? OrderDirection::Desc
+                    : OrderDirection::Asc;
+            }
 
-            if (!empty($firstExtracted['operators'])) {
-                $hasOperators = true;
-            } else {
-                foreach ($changes as $change) {
-                    $doc = $change->getNew();
-                    $extracted = Operator::extractOperators($doc->getAttributes());
-                    if (!empty($extracted['operators'])) {
-                        $hasOperators = true;
-                        break;
-                    }
+            $internalAttr = $resolveInternalKey($originalAttribute);
+
+            if (count($orderAttributes) === 1 && $i === 0 && $originalAttribute === Document::SEQUENCE) {
+                /** @var bool|float|int|string $cursorVal */
+                $cursorVal = $cursor[$originalAttribute];
+                if ($direction === OrderDirection::Desc) {
+                    $cursorConditions[] = BaseQuery::lessThan($internalAttr, $cursorVal);
+                } else {
+                    $cursorConditions[] = BaseQuery::greaterThan($internalAttr, $cursorVal);
                 }
+                break;
             }
 
-            if (!$hasOperators) {
-                $bindIndex = 0;
-                $batchKeys = [];
-                $bindValues = [];
-                $allColumnNames = [];
-                $documentsData = [];
+            $andConditions = [];
 
-                foreach ($changes as $change) {
-                    $document = $change->getNew();
-                    $currentRegularAttributes = $document->getAttributes();
+            for ($j = 0; $j < $i; $j++) {
+                $prevOriginal = $orderAttributes[$j];
+                $prevAttr = $resolveInternalKey($prevOriginal);
+                /** @var array<array<mixed>|bool|float|int|string|null> $prevCursorVals */
+                $prevCursorVals = [$cursor[$prevOriginal]];
+                $andConditions[] = BaseQuery::equal($prevAttr, $prevCursorVals);
+            }
 
-                    $currentRegularAttributes['_uid'] = $document->getId();
-                    $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? DateTime::setTimezone($document->getCreatedAt()) : null;
-                    $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? DateTime::setTimezone($document->getUpdatedAt()) : null;
-                    $currentRegularAttributes['_permissions'] = \json_encode($document->getPermissions());
+            /** @var bool|float|int|string $cursorAttrVal */
+            $cursorAttrVal = $cursor[$originalAttribute];
+            if ($direction === OrderDirection::Desc) {
+                $andConditions[] = BaseQuery::lessThan($internalAttr, $cursorAttrVal);
+            } else {
+                $andConditions[] = BaseQuery::greaterThan($internalAttr, $cursorAttrVal);
+            }
 
-                    if (!empty($document->getSequence())) {
-                        $currentRegularAttributes['_id'] = $document->getSequence();
-                    }
+            if (count($andConditions) === 1) {
+                $cursorConditions[] = $andConditions[0];
+            } else {
+                $cursorConditions[] = BaseQuery::and($andConditions);
+            }
+        }
+
+        if ($cursorConditions === []) {
+            return;
+        }
+
+        if (count($cursorConditions) === 1) {
+            $builder->filter($cursorConditions);
+        } else {
+            $builder->filter([BaseQuery::or($cursorConditions)]);
+        }
+    }
 
-                    if ($this->sharedTables) {
-                        $currentRegularAttributes['_tenant'] = $document->getTenant();
+    /**
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string>  $joinAliases
+     */
+    private function applyFindPage(
+        SQLBuilder $builder,
+        array $orderAttributes,
+        array $orderTypes,
+        ?int $limit,
+        ?int $offset,
+        CursorDirection $cursorDirection = CursorDirection::After,
+        bool $afterUnion = false,
+        array $joinAliases = [],
+    ): void {
+        if ($afterUnion) {
+            $quote = $this->getIdentifierQuoteChar();
+            $builder->afterBuild(function (Statement $result) use (
+                $orderAttributes,
+                $orderTypes,
+                $limit,
+                $offset,
+                $cursorDirection,
+                $quote,
+            ): Statement {
+                $sql = $result->query;
+                $bindings = $result->bindings;
+
+                $orderParts = [];
+                foreach (\array_keys($orderAttributes) as $i) {
+                    $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+                    if ($orderType === OrderDirection::Random) {
+                        $orderParts[] = $this->createBuilder()->compileOrder(BaseQuery::orderRandom());
+
+                        continue;
                     }
 
-                    foreach (\array_keys($currentRegularAttributes) as $colName) {
-                        $allColumnNames[$colName] = true;
+                    $direction = $orderType;
+                    if ($cursorDirection === CursorDirection::Before) {
+                        $direction = ($direction === OrderDirection::Asc)
+                            ? OrderDirection::Desc
+                            : OrderDirection::Asc;
                     }
 
-                    $documentsData[] = ['regularAttributes' => $currentRegularAttributes];
+                    $orderParts[] = $quote.self::FOJ_ORDER_ALIAS_PREFIX.$i.$quote.($direction === OrderDirection::Desc ? ' DESC' : ' ASC');
                 }
 
-                $allColumnNames = \array_keys($allColumnNames);
-                \sort($allColumnNames);
-
-                $columnsArray = [];
-                foreach ($allColumnNames as $attr) {
-                    $columnsArray[] = "{$this->quote($this->filter($attr))}";
+                if ($orderParts !== []) {
+                    $sql .= ' ORDER BY '.\implode(', ', $orderParts);
+                }
+                if (! \is_null($limit)) {
+                    $sql .= ' LIMIT ?';
+                    $bindings[] = $limit;
+                }
+                if (! \is_null($offset)) {
+                    $sql .= ' OFFSET ?';
+                    $bindings[] = $offset;
                 }
-                $columns = '(' . \implode(', ', $columnsArray) . ')';
 
-                foreach ($documentsData as $docData) {
-                    $currentRegularAttributes = $docData['regularAttributes'];
-                    $bindKeys = [];
+                return new Statement($sql, $bindings, $result->readOnly);
+            });
 
-                    foreach ($allColumnNames as $attributeKey) {
-                        $attrValue = $currentRegularAttributes[$attributeKey] ?? null;
+            return;
+        }
 
-                        if (\is_array($attrValue)) {
-                            $attrValue = \json_encode($attrValue);
-                        }
+        foreach ($orderAttributes as $i => $originalAttribute) {
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
 
-                        if (in_array($attributeKey, $spatialAttributes) && $attrValue !== null) {
-                            $bindKey = 'key_' . $bindIndex;
-                            $bindKeys[] = $this->getSpatialGeomFromText(":" . $bindKey);
-                        } else {
-                            if ($this->getSupportForIntegerBooleans()) {
-                                $attrValue = (\is_bool($attrValue)) ? (int)$attrValue : $attrValue;
-                            }
-                            $bindKey = 'key_' . $bindIndex;
-                            $bindKeys[] = ':' . $bindKey;
-                        }
-                        $bindValues[$bindKey] = $attrValue;
-                        $bindIndex++;
-                    }
+            if ($orderType === OrderDirection::Random) {
+                $builder->sortRandom();
 
-                    $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
-                }
+                continue;
+            }
 
-                $regularAttributes = [];
-                foreach ($allColumnNames as $colName) {
-                    $regularAttributes[$colName] = null;
-                }
-                foreach ($documentsData[0]['regularAttributes'] as $key => $value) {
-                    $regularAttributes[$key] = $value;
-                }
+            $internalAttr = $this->qualifyOrderAttribute($originalAttribute, $joinAliases);
+            $direction = $orderType;
 
-                $stmt = $this->getUpsertStatement($name, $columns, $batchKeys, $regularAttributes, $bindValues, $attribute, []);
-                $stmt->execute();
-                $stmt->closeCursor();
-            } else {
-                $groups = [];
+            if ($cursorDirection === CursorDirection::Before) {
+                $direction = ($direction === OrderDirection::Asc)
+                    ? OrderDirection::Desc
+                    : OrderDirection::Asc;
+            }
 
-                foreach ($changes as $change) {
-                    $document = $change->getNew();
-                    $extracted = Operator::extractOperators($document->getAttributes());
-                    $operators = $extracted['operators'];
+            if ($direction === OrderDirection::Desc) {
+                $builder->sortDesc($internalAttr);
+            } else {
+                $builder->sortAsc($internalAttr);
+            }
+        }
 
-                    if (empty($operators)) {
-                        $signature = 'no_ops';
-                    } else {
-                        $parts = [];
-                        foreach ($operators as $attr => $op) {
-                            $parts[] = $attr . ':' . $op->getMethod() . ':' . json_encode($op->getValues());
-                        }
-                        sort($parts);
-                        $signature = implode('|', $parts);
-                    }
+        if (! \is_null($limit)) {
+            $builder->limit($limit);
+        }
+        if (! \is_null($offset)) {
+            $builder->offset($offset);
+        }
+    }
 
-                    if (!isset($groups[$signature])) {
-                        $groups[$signature] = [
-                            'documents' => [],
-                            'operators' => $operators
-                        ];
-                    }
+    /**
+     * @return array<int, array<string, mixed>>
+     */
+    private function executeSelect(SQLBuilder $builder, Event $event): array
+    {
+        try {
+            $result = $builder->build();
+        } catch (ValidationException|UnsupportedException $e) {
+            throw new QueryException($e->getMessage(), $e->getCode(), $e);
+        }
 
-                    $groups[$signature]['documents'][] = $change;
+        $stmt = null;
+        $results = [];
+        $exception = null;
+        try {
+            $stmt = $this->executeResult($result, $event);
+            $this->execute($stmt);
+            /** @var array<int, array<string, mixed>> $results */
+            $results = $stmt->fetchAll();
+        } catch (PDOException $e) {
+            $exception = $e;
+        } finally {
+            if ($stmt !== null) {
+                try {
+                    $stmt->closeCursor();
+                } catch (PDOException $e) {
+                    $exception ??= $e;
                 }
+            }
+        }
 
-                foreach ($groups as $group) {
-                    $groupChanges = $group['documents'];
-                    $operators = $group['operators'];
-
-                    $bindIndex = 0;
-                    $batchKeys = [];
-                    $bindValues = [];
-                    $allColumnNames = [];
-                    $documentsData = [];
-
-                    foreach ($groupChanges as $change) {
-                        $document = $change->getNew();
-                        $attributes = $document->getAttributes();
-
-                        $extracted = Operator::extractOperators($attributes);
-                        $currentRegularAttributes = $extracted['updates'];
-                        $extractedOperators = $extracted['operators'];
-
-                        // For new documents, apply operators to attribute defaults
-                        if ($change->getOld()->isEmpty() && !empty($extractedOperators)) {
-                            foreach ($extractedOperators as $operatorKey => $operator) {
-                                $default = $attributeDefaults[$operatorKey] ?? null;
-                                $currentRegularAttributes[$operatorKey] = $this->applyOperatorToValue($operator, $default);
-                            }
-                        }
+        if ($exception !== null) {
+            throw $this->processException($exception);
+        }
 
-                        $currentRegularAttributes['_uid'] = $document->getId();
-                        $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
-                        $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
-                        $currentRegularAttributes['_permissions'] = \json_encode($document->getPermissions());
+        return $results;
+    }
 
-                        if (!empty($document->getSequence())) {
-                            $currentRegularAttributes['_id'] = $document->getSequence();
-                        }
+    private function sanitizeJoinAlias(string $alias): string
+    {
+        if ($alias !== '' && \preg_match('/^[A-Za-z_][A-Za-z0-9_]*$/', $alias) === 1) {
+            return $alias;
+        }
 
-                        if ($this->sharedTables) {
-                            $currentRegularAttributes['_tenant'] = $document->getTenant();
-                        }
+        return '';
+    }
 
-                        foreach (\array_keys($currentRegularAttributes) as $colName) {
-                            $allColumnNames[$colName] = true;
-                        }
+    private function qualifyJoinColumn(string $column, string $defaultAlias): string
+    {
+        $dot = \strpos($column, '.');
+        if ($dot === false) {
+            return $defaultAlias.'.'.$this->getInternalKeyForAttribute($column);
+        }
 
-                        $documentsData[] = ['regularAttributes' => $currentRegularAttributes];
-                    }
+        $prefix = \substr($column, 0, $dot);
+        $name = \substr($column, $dot + 1);
 
-                    foreach (\array_keys($operators) as $colName) {
-                        $allColumnNames[$colName] = true;
-                    }
+        return $prefix.'.'.$this->getInternalKeyForAttribute($name);
+    }
 
-                    $allColumnNames = \array_keys($allColumnNames);
-                    \sort($allColumnNames);
+    /**
+     * @param  array<string>  $joinAliases
+     */
+    private function qualifyOrderAttribute(string $attribute, array $joinAliases = []): string
+    {
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false) {
+            $prefix = \substr($attribute, 0, $dot);
+            if (\in_array($prefix, $joinAliases, true)) {
+                $name = \substr($attribute, $dot + 1);
 
-                    $columnsArray = [];
-                    foreach ($allColumnNames as $attr) {
-                        $columnsArray[] = "{$this->quote($this->filter($attr))}";
-                    }
-                    $columns = '(' . \implode(', ', $columnsArray) . ')';
-
-                    foreach ($documentsData as $docData) {
-                        $currentRegularAttributes = $docData['regularAttributes'];
-                        $bindKeys = [];
-
-                        foreach ($allColumnNames as $attributeKey) {
-                            $attrValue = $currentRegularAttributes[$attributeKey] ?? null;
-
-                            if (\is_array($attrValue)) {
-                                $attrValue = \json_encode($attrValue);
-                            }
-
-                            if (in_array($attributeKey, $spatialAttributes) && $attrValue !== null) {
-                                $bindKey = 'key_' . $bindIndex;
-                                $bindKeys[] = $this->getSpatialGeomFromText(":" . $bindKey);
-                            } else {
-                                if ($this->getSupportForIntegerBooleans()) {
-                                    $attrValue = (\is_bool($attrValue)) ? (int)$attrValue : $attrValue;
-                                }
-                                $bindKey = 'key_' . $bindIndex;
-                                $bindKeys[] = ':' . $bindKey;
-                            }
-                            $bindValues[$bindKey] = $attrValue;
-                            $bindIndex++;
-                        }
+                return $this->filter($prefix).'.'.$this->filter($this->getInternalKeyForAttribute($name));
+            }
+        }
 
-                        $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
-                    }
+        return $this->filter($this->getInternalKeyForAttribute($attribute));
+    }
 
-                    $regularAttributes = [];
-                    foreach ($allColumnNames as $colName) {
-                        $regularAttributes[$colName] = null;
-                    }
-                    foreach ($documentsData[0]['regularAttributes'] as $key => $value) {
-                        $regularAttributes[$key] = $value;
-                    }
+    /**
+     * @param array<string, mixed> $row
+     */
+    private function remapRow(array &$row): void
+    {
+        $identityColumns = [
+            Storage::UID => true,
+            Storage::SEQUENCE => true,
+            Storage::PERMISSIONS => true,
+            Storage::CREATED_AT => true,
+            Storage::UPDATED_AT => true,
+            Storage::COLLECTION => true,
+            Storage::TENANT => true,
+            Storage::VERSION => true,
+            Document::ID => true,
+            Document::SEQUENCE => true,
+            Document::PERMISSIONS => true,
+            Document::CREATED_AT => true,
+            Document::UPDATED_AT => true,
+            Document::COLLECTION => true,
+            Document::TENANT => true,
+            Document::VERSION => true,
+        ];
 
-                    $stmt = $this->getUpsertStatement(
-                        $name,
-                        $columns,
-                        $batchKeys,
-                        $regularAttributes,
-                        $bindValues,
-                        '',
-                        $operators
-                    );
+        foreach (\array_keys($row) as $key) {
+            if (\str_starts_with($key, self::FOJ_ORDER_ALIAS_PREFIX)) {
+                unset($row[$key]);
 
-                    $stmt->execute();
-                    $stmt->closeCursor();
-                }
+                continue;
+            }
+            if (! \str_contains($key, '.')) {
+                continue;
+            }
+            $separator = \strrpos($key, '.');
+            if (! \is_int($separator)) {
+                continue;
+            }
+            $prefix = \substr($key, 0, $separator);
+            $bare = \trim(\substr($key, $separator + 1), '`"');
+            $public = Storage::attribute($bare);
+            $dotted = $prefix.'.'.$public;
+            $identity = isset($identityColumns[$bare]);
+            $mainAlias = $prefix === Query::DEFAULT_ALIAS;
+
+            if ($bare !== '' && ! \array_key_exists($bare, $row) && (! $identity || $mainAlias)) {
+                $row[$bare] = $row[$key];
             }
 
-            $removeQueries = [];
-            $removeBindValues = [];
-            $addQueries = [];
-            $addBindValues = [];
+            $value = $row[$key];
+            if ($bare === Storage::PERMISSIONS || $public === Document::PERMISSIONS) {
+                $value = \json_decode(\is_string($value) ? $value : '[]', true);
+            }
+            if (! \array_key_exists($dotted, $row) || $key === $dotted) {
+                $row[$dotted] = $value;
+            }
+            if ($key !== $dotted) {
+                unset($row[$key]);
+            }
+        }
 
-            foreach ($changes as $index => $change) {
-                $old = $change->getOld();
-                $document = $change->getNew();
+        foreach (Storage::columnMap() as $internal => $public) {
+            if ($internal === Storage::PERMISSIONS || $internal === Storage::DISTANCE) {
+                continue;
+            }
+            if (\array_key_exists($internal, $row)) {
+                $row[$public] = $row[$internal];
+                unset($row[$internal]);
+            }
+        }
+        if (\array_key_exists(Storage::PERMISSIONS, $row)) {
+            $row[Document::PERMISSIONS] = \json_decode(\is_string($row[Storage::PERMISSIONS]) ? $row[Storage::PERMISSIONS] : '[]', true);
+            unset($row[Storage::PERMISSIONS]);
+        }
+        if (\array_key_exists(Storage::DISTANCE, $row)) {
+            $distance = $row[Storage::DISTANCE];
+            $row[Document::DISTANCE] = \is_numeric($distance) ? (float) $distance : null;
+            unset($row[Storage::DISTANCE]);
+        }
+    }
 
-                $current = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $current[$type] = $old->getPermissionsByType($type);
-                }
+    /**
+     * Build a key-value row array from a Document for batch INSERT.
+     *
+     * Converts internal attributes ($id, $createdAt, etc.) to their column names
+     * and encodes arrays as JSON. Spatial attributes are included with their raw
+     * value (the caller must handle ST_GeomFromText wrapping separately).
+     *
+     * @param  list<string>  $attributeKeys
+     * @param  array<string, true>  $spatialMap  Pre-built lookup map; the caller
+     *         hoists this out of the per-document loop so we don't allocate it
+     *         per row in batch inserts.
+     * @return array<string, mixed>
+     */
+    protected function buildDocumentRow(Document $document, array $attributeKeys, array $spatialMap = [], ?bool $intBools = null): array
+    {
+        $attributes = $document->getAttributes();
+        $row = [
+            Storage::UID => $document->getId(),
+            Storage::CREATED_AT => $document->getCreatedAt(),
+            Storage::UPDATED_AT => $document->getUpdatedAt(),
+            Storage::PERMISSIONS => \json_encode($document->getPermissions()),
+        ];
 
-                foreach (Database::PERMISSIONS as $type) {
-                    $toRemove = \array_diff($current[$type], $document->getPermissionsByType($type));
-                    if (!empty($toRemove)) {
-                        $removeQueries[] = "(
-                            _document = :_uid_{$index}
-                            " . ($this->sharedTables ? " AND _tenant = :_tenant_{$index}" : '') . "
-                            AND _type = '{$type}'
-                            AND _permission IN (" . \implode(',', \array_map(fn ($i) => ":remove_{$type}_{$index}_{$i}", \array_keys($toRemove))) . ")
-                        )";
-                        $removeBindValues[":_uid_{$index}"] = $document->getId();
-                        if ($this->sharedTables) {
-                            $removeBindValues[":_tenant_{$index}"] = $document->getTenant();
-                        }
-                        foreach ($toRemove as $i => $perm) {
-                            $removeBindValues[":remove_{$type}_{$index}_{$i}"] = $perm;
-                        }
-                    }
-                }
+        $version = $document->getVersion();
+        if ($version !== null) {
+            $row[Storage::VERSION] = $version;
+        }
 
-                foreach (Database::PERMISSIONS as $type) {
-                    $toAdd = \array_diff($document->getPermissionsByType($type), $current[$type]);
+        if (! empty($document->getSequence())) {
+            $row[Storage::SEQUENCE] = $document->getSequence();
+        }
 
-                    foreach ($toAdd as $i => $permission) {
-                        $addQuery = "(:_uid_{$index}, '{$type}', :add_{$type}_{$index}_{$i}";
+        $intBools ??= $this->supports(Capability::IntegerBooleans);
 
-                        if ($this->sharedTables) {
-                            $addQuery .= ", :_tenant_{$index}";
-                        }
+        foreach ($attributeKeys as $key) {
+            if (isset($row[$key])) {
+                continue;
+            }
+            $value = $attributes[$key] ?? null;
+            if (isset($spatialMap[$key]) || $this->isSpatialWkt($value)) {
+                $value = $this->encodeSpatialWriteValue($value);
+            } elseif (\is_array($value)) {
+                $value = \json_encode($value);
+            }
+            if ($intBools && ! isset($spatialMap[$key])) {
+                $value = (\is_bool($value)) ? (int) $value : $value;
+            }
+            $row[$key] = $value;
+        }
 
-                        $addQuery .= ")";
-                        $addQueries[] = $addQuery;
-                        $addBindValues[":_uid_{$index}"] = $document->getId();
-                        $addBindValues[":add_{$type}_{$index}_{$i}"] = $permission;
+        return $row;
+    }
 
-                        if ($this->sharedTables) {
-                            $addBindValues[":_tenant_{$index}"] = $document->getTenant();
-                        }
-                    }
-                }
-            }
+    /**
+     * Helper method to extract spatial type attributes from collection attributes.
+     *
+     * The result is memoized by collection id and an attribute-set fingerprint
+     * so a process that created documents before spatial columns existed does
+     * not keep serving an empty list. Invalidate via
+     * invalidateSpatialAttributesCache() when adding or removing attributes.
+     *
+     * @return list<string>
+     */
+    protected function getSpatialAttributes(Document $collection): array
+    {
+        $key = $this->spatialCacheKey($collection->getId());
+        /** @var array<mixed> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $fingerprint = $this->spatialAttributeFingerprint($collectionAttributes);
+        $cached = $this->spatialAttributesCache[$key] ?? null;
+        if ($cached !== null && $cached['fingerprint'] === $fingerprint) {
+            return $cached['attributes'];
+        }
 
-            if (!empty($removeQueries)) {
-                $removeQuery = \implode(' OR ', $removeQueries);
-                $stmtRemovePermissions = $this->getPDO()->prepare("DELETE FROM {$this->getSQLTable($name . '_perms')} WHERE {$removeQuery}");
-                foreach ($removeBindValues as $key => $value) {
-                    $stmtRemovePermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
-                $stmtRemovePermissions->execute();
+        $spatialAttributes = [];
+        $spatialTypes = [ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value];
+        foreach ($collectionAttributes as $attr) {
+            [$attributeKey, $attributeType] = $this->attributeKeyAndType($attr);
+            if (\is_string($attributeKey) && \in_array($attributeType, $spatialTypes, true)) {
+                $spatialAttributes[] = $attributeKey;
             }
+        }
 
-            if (!empty($addQueries)) {
-                $sqlAddPermissions = "INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission";
-                if ($this->sharedTables) {
-                    $sqlAddPermissions .= ", _tenant";
-                }
-                $sqlAddPermissions .= ") VALUES " . \implode(', ', $addQueries);
-                $stmtAddPermissions = $this->getPDO()->prepare($sqlAddPermissions);
-                foreach ($addBindValues as $key => $value) {
-                    $stmtAddPermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
-                $stmtAddPermissions->execute();
+        $this->spatialAttributesCache[$key] = [
+            'fingerprint' => $fingerprint,
+            'attributes' => $spatialAttributes,
+        ];
+
+        return $spatialAttributes;
+    }
+
+    /**
+     * @param  array<mixed>  $collectionAttributes
+     */
+    private function spatialAttributeFingerprint(array $collectionAttributes): string
+    {
+        $parts = [];
+        foreach ($collectionAttributes as $attr) {
+            [$key, $type] = $this->attributeKeyAndType($attr);
+            if (\is_string($key)) {
+                $parts[] = $key.':'.($type ?? '');
             }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
         }
+        \sort($parts);
 
-        return \array_map(fn ($change) => $change->getNew(), $changes);
+        return \implode(',', $parts);
     }
 
     /**
-     * Build geometry WKT string from array input for spatial queries
-     *
-     * @param array<mixed> $geometry
-     * @return string
-     * @throws DatabaseException
+     * @return array{0: ?string, 1: ?string}
      */
-    protected function convertArrayToWKT(array $geometry): string
+    private function attributeKeyAndType(mixed $attr): array
     {
-        // point [x, y]
-        if (count($geometry) === 2 && is_numeric($geometry[0]) && is_numeric($geometry[1])) {
-            return "POINT({$geometry[0]} {$geometry[1]})";
+        if ($attr instanceof Attribute) {
+            return [$attr->key, $attr->type->value];
         }
 
-        // linestring [[x1, y1], [x2, y2], ...]
-        if (is_array($geometry[0]) && count($geometry[0]) === 2 && is_numeric($geometry[0][0])) {
-            $points = [];
-            foreach ($geometry as $point) {
-                if (!is_array($point) || count($point) !== 2 || !is_numeric($point[0]) || !is_numeric($point[1])) {
-                    throw new DatabaseException('Invalid point format in geometry array');
-                }
-                $points[] = "{$point[0]} {$point[1]}";
-            }
-            return 'LINESTRING(' . implode(', ', $points) . ')';
+        if ($attr instanceof Document) {
+            $type = $attr->getAttribute('type');
+            $key = $attr->getAttribute('key', $attr->getId());
+        } elseif (\is_array($attr)) {
+            $type = $attr['type'] ?? null;
+            $key = $attr['key'] ?? $attr[Document::ID] ?? null;
+        } else {
+            return [null, null];
         }
 
-        // polygon [[[x1, y1], [x2, y2], ...], ...]
-        if (is_array($geometry[0]) && is_array($geometry[0][0]) && count($geometry[0][0]) === 2) {
-            $rings = [];
-            foreach ($geometry as $ring) {
-                if (!is_array($ring)) {
-                    throw new DatabaseException('Invalid ring format in polygon geometry');
-                }
-                $points = [];
-                foreach ($ring as $point) {
-                    if (!is_array($point) || count($point) !== 2 || !is_numeric($point[0]) || !is_numeric($point[1])) {
-                        throw new DatabaseException('Invalid point format in polygon ring');
-                    }
-                    $points[] = "{$point[0]} {$point[1]}";
-                }
-                $rings[] = '(' . implode(', ', $points) . ')';
-            }
-            return 'POLYGON(' . implode(', ', $rings) . ')';
+        if ($type instanceof ColumnType) {
+            $type = $type->value;
         }
 
-        throw new DatabaseException('Unrecognized geometry array format');
+        return [
+            \is_string($key) ? $key : null,
+            \is_string($type) ? $type : null,
+        ];
     }
 
     /**
-     * Find Documents
-     *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $limit
-     * @param int|null $offset
-     * @param array<string> $orderAttributes
-     * @param array<string> $orderTypes
-     * @param array<string, mixed> $cursor
-     * @param string $cursorDirection
-     * @param string $forPermission
-     * @return array<Document>
-     * @throws DatabaseException
-     * @throws TimeoutException
-     * @throws Exception
+     * @param  list<string>  $spatialAttributes
+     * @param  array<Document>  $documents
+     * @return list<string>
      */
-    public function find(Document $collection, array $queries = [], ?int $limit = 25, ?int $offset = null, array $orderAttributes = [], array $orderTypes = [], array $cursor = [], string $cursorDirection = Database::CURSOR_AFTER, string $forPermission = Database::PERMISSION_READ): array
+    protected function expandSpatialAttributes(array $spatialAttributes, array $documents): array
     {
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
-        $roles = $this->authorization->getRoles();
-        $where = [];
-        $orders = [];
-        $alias = Query::DEFAULT_ALIAS;
-        $binds = [];
-
-        $queries = array_map(fn ($query) => clone $query, $queries);
-
-        // Extract vector queries for ORDER BY
-        $vectorQueries = [];
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if (in_array($query->getMethod(), Query::VECTOR_TYPES)) {
-                $vectorQueries[] = $query;
-            } else {
-                $otherQueries[] = $query;
+        $spatialMap = \array_fill_keys($spatialAttributes, true);
+        foreach ($documents as $document) {
+            foreach ($document->getAttributes() as $key => $value) {
+                if (! isset($spatialMap[$key]) && $this->isSpatialWkt($value)) {
+                    $spatialAttributes[] = $key;
+                    $spatialMap[$key] = true;
+                }
             }
         }
 
-        $queries = $otherQueries;
+        return $spatialAttributes;
+    }
 
-        $cursorWhere = [];
+    protected function isSpatialWriteValue(mixed $value): bool
+    {
+        if ($this->isSpatialWkt($value)) {
+            return true;
+        }
 
-        foreach ($orderAttributes as $i => $originalAttribute) {
-            $orderType = $orderTypes[$i] ?? Database::ORDER_ASC;
+        if (! \is_array($value) || $value === []) {
+            return false;
+        }
 
-            // Handle random ordering
-            if ($orderType === Database::ORDER_RANDOM) {
-                $orders[] = $this->getRandomOrder();
-                continue;
-            }
+        try {
+            $this->convertArrayToWKT($value);
 
-            $attribute = $this->getInternalKeyForAttribute($originalAttribute);
-            $attribute = $this->filter($attribute);
+            return true;
+        } catch (DatabaseException) {
+            return false;
+        }
+    }
 
-            $orderType = $this->filter($orderType);
-            $direction = $orderType;
+    protected function encodeSpatialWriteValue(mixed $value): mixed
+    {
+        if (\is_array($value)) {
+            return $this->convertArrayToWKT($value);
+        }
 
-            if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $direction = ($direction === Database::ORDER_ASC)
-                    ? Database::ORDER_DESC
-                    : Database::ORDER_ASC;
-            }
+        return $value;
+    }
 
-            $orders[] = "{$this->quote($attribute)} {$direction}";
+    /**
+     * Invalidate the spatial attributes cache for a collection. Called from
+     * createAttribute / deleteAttribute / updateAttribute / renameAttribute /
+     * deleteCollection paths so the next write rescans the column list.
+     */
+    protected function invalidateSpatialAttributesCache(string $collectionId): void
+    {
+        unset($this->spatialAttributesCache[$this->spatialCacheKey($collectionId)]);
+    }
 
-            // Build pagination WHERE clause only if we have a cursor
-            if (!empty($cursor)) {
-                // Special case: No tie breaks. only 1 attribute and it's a unique primary key
-                if (count($orderAttributes) === 1 && $i === 0 && $originalAttribute === '$sequence') {
-                    $operator = ($direction === Database::ORDER_DESC)
-                        ? Query::TYPE_LESSER
-                        : Query::TYPE_GREATER;
+    /**
+     * Compose a cache key scoped to the current database and namespace so
+     * that Pool sibling adapters reused across schemas never collide on a
+     * shared collection id. Tenant is intentionally excluded: collection
+     * schema (and therefore the spatial-attribute set) is shared across
+     * tenants under shared tables.
+     */
+    private function spatialCacheKey(string $collectionId): string
+    {
+        return $this->database.'/'.$this->namespace.'/'.$collectionId;
+    }
 
-                    $bindName = ":cursor_pk";
-                    $binds[$bindName] = $cursor[$originalAttribute];
+    /**
+     * Generate SQL expression for operator
+     * Each adapter must implement operators specific to their SQL dialect
+     *
+     * @return string|null Returns null if operator can't be expressed in SQL
+     */
+    abstract protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string;
 
-                    $cursorWhere[] = "{$this->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
-                    break;
+    /**
+     * Bind operator parameters to prepared statement
+     */
+    protected function bindOperatorParams(PDOStatement|DatabasePDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
+    {
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+
+        switch ($method) {
+            // Numeric operators with optional limits
+            case OperatorType::Increment:
+            case OperatorType::Decrement:
+            case OperatorType::Multiply:
+            case OperatorType::Divide:
+                $value = $values[0] ?? 1;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, $this->getPDOType($value));
+                $bindIndex++;
+
+                // Bind limit if provided
+                if (isset($values[1])) {
+                    $limitKey = "op_{$bindIndex}";
+                    $stmt->bindValue(':'.$limitKey, $values[1], $this->getPDOType($values[1]));
+                    $bindIndex++;
+                }
+                break;
+
+            case OperatorType::Modulo:
+                $value = $values[0] ?? 1;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, $this->getPDOType($value));
+                $bindIndex++;
+                break;
+
+            case OperatorType::Power:
+                $value = $values[0] ?? 1;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, $this->getPDOType($value));
+                $bindIndex++;
+
+                // Bind max limit if provided
+                if (isset($values[1])) {
+                    $maxKey = "op_{$bindIndex}";
+                    $stmt->bindValue(':'.$maxKey, $values[1], $this->getPDOType($values[1]));
+                    $bindIndex++;
                 }
+                break;
 
-                $conditions = [];
+                // String operators
+            case OperatorType::StringConcat:
+                $value = $values[0] ?? '';
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::StringReplace:
+                $search = $values[0] ?? '';
+                $replace = $values[1] ?? '';
+                $searchKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$searchKey, $search, PDO::PARAM_STR);
+                $bindIndex++;
+                $replaceKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$replaceKey, $replace, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
 
-                // Add equality conditions for previous attributes
-                for ($j = 0; $j < $i; $j++) {
-                    $prevOriginal = $orderAttributes[$j];
-                    $prevAttr = $this->filter($this->getInternalKeyForAttribute($prevOriginal));
+                // Boolean operators
+            case OperatorType::Toggle:
+                // No parameters to bind
+                break;
 
-                    $bindName = ":cursor_{$j}";
-                    $binds[$bindName] = $cursor[$prevOriginal];
+                // Date operators
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                $days = $values[0] ?? 0;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $days, PDO::PARAM_INT);
+                $bindIndex++;
+                break;
+
+            case OperatorType::DateSetNow:
+                // No parameters to bind
+                break;
 
-                    $conditions[] = "{$this->quote($alias)}.{$this->quote($prevAttr)} = {$bindName}";
+                // Array operators
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                // PERFORMANCE: Validate array size to prevent memory exhaustion
+                if (\count($values) > Operator::MAX_ARRAY_OPERATOR_SIZE) {
+                    throw new DatabaseException('Array size '.\count($values).' exceeds maximum allowed size of '.Operator::MAX_ARRAY_OPERATOR_SIZE.' for array operations');
                 }
 
-                // Add comparison for current attribute
-                $operator = ($direction === Database::ORDER_DESC)
-                    ? Query::TYPE_LESSER
-                    : Query::TYPE_GREATER;
+                // Bind JSON array
+                $arrayValue = json_encode($values);
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::ArrayRemove:
+                $value = $values[0] ?? null;
+                $bindKey = "op_{$bindIndex}";
+                if (is_array($value)) {
+                    $value = json_encode($value);
+                }
+                $stmt->bindValue(':'.$bindKey, $value, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
 
-                $bindName = ":cursor_{$i}";
-                $binds[$bindName] = $cursor[$originalAttribute];
+            case OperatorType::ArrayUnique:
+                // No parameters to bind
+                break;
 
-                $conditions[] = "{$this->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
+                // Complex array operators
+            case OperatorType::ArrayInsert:
+                $index = $values[0] ?? 0;
+                $value = $values[1] ?? null;
+                $indexKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$indexKey, $index, PDO::PARAM_INT);
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$valueKey, json_encode($value), PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                // PERFORMANCE: Validate array size to prevent memory exhaustion
+                if (\count($values) > Operator::MAX_ARRAY_OPERATOR_SIZE) {
+                    throw new DatabaseException('Array size '.\count($values).' exceeds maximum allowed size of '.Operator::MAX_ARRAY_OPERATOR_SIZE.' for array operations');
+                }
 
-                $cursorWhere[] = '(' . implode(' AND ', $conditions) . ')';
-            }
-        }
+                $arrayValue = json_encode($values);
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
+
+            case OperatorType::ArrayFilter:
+                $condition = \is_string($values[0] ?? null) ? $values[0] : 'equal';
+                $value = $values[1] ?? null;
+
+                $validConditions = [
+                    'equal', 'notEqual',  // Comparison
+                    'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual',  // Numeric
+                    'isNull', 'isNotNull',  // Null checks
+                ];
+                if (! in_array($condition, $validConditions, true)) {
+                    throw new DatabaseException("Invalid filter condition: {$condition}. Must be one of: ".implode(', ', $validConditions));
+                }
 
-        if (!empty($cursorWhere)) {
-            $where[] = '(' . implode(' OR ', $cursorWhere) . ')';
+                $conditionKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$conditionKey, $condition, PDO::PARAM_STR);
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                if ($value !== null) {
+                    $stmt->bindValue(':'.$valueKey, json_encode($value), PDO::PARAM_STR);
+                } else {
+                    $stmt->bindValue(':'.$valueKey, null, PDO::PARAM_NULL);
+                }
+                $bindIndex++;
+                break;
         }
+    }
 
-        $conditions = $this->getSQLConditionsForCollection($name, $queries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
-        }
+    /**
+     * Get the operator expression and positional bindings for use with the query builder's setRaw().
+     *
+     * Calls getOperatorSQL() to get the expression with named bindings, strips the
+     * column assignment prefix, and converts named :op_N bindings to positional ? placeholders.
+     *
+     * @param  string  $column  The unquoted column name
+     * @param  Operator  $operator  The operator to convert
+     * @return array{expression: string, bindings: list<mixed>} The expression and binding values
+     *
+     * @throws DatabaseException
+     */
+    protected function getOperatorBuilderExpression(string $column, Operator $operator): array
+    {
+        $bindIndex = 0;
+        $fullExpression = $this->getOperatorSQL($column, $operator, $bindIndex);
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias, $forPermission);
+        if ($fullExpression === null) {
+            throw new DatabaseException('Operator cannot be expressed in SQL: '.$operator->getMethod()->value);
         }
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
+        // Strip the "quotedColumn = " prefix to get just the RHS expression
+        $quotedColumn = $this->quote($column);
+        $prefix = $quotedColumn.' = ';
+        $expression = $fullExpression;
+        if (str_starts_with($expression, $prefix)) {
+            $expression = substr($expression, strlen($prefix));
         }
 
-        $sqlWhere = !empty($where) ? 'WHERE ' . implode(' AND ', $where) : '';
+        // Collect the named binding keys and their values in order
+        /** @var array<string, mixed> $namedBindings */
+        $namedBindings = [];
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+        $idx = 0;
 
-        $vectorDistances = [];
-        foreach ($vectorQueries as $query) {
-            $vectorDistance = $this->getSQLVectorDistance($query, $binds, $alias);
-            if ($vectorDistance) {
-                $vectorDistances[] = $vectorDistance;
-            }
+        switch ($method) {
+            case OperatorType::Increment:
+            case OperatorType::Decrement:
+            case OperatorType::Multiply:
+            case OperatorType::Divide:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                if (isset($values[1])) {
+                    $namedBindings["op_{$idx}"] = $values[1];
+                    $idx++;
+                }
+                break;
+
+            case OperatorType::Modulo:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                break;
+
+            case OperatorType::Power:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                if (isset($values[1])) {
+                    $namedBindings["op_{$idx}"] = $values[1];
+                    $idx++;
+                }
+                break;
+
+            case OperatorType::StringConcat:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                break;
+
+            case OperatorType::StringReplace:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                $namedBindings["op_{$idx}"] = $values[1] ?? '';
+                $idx++;
+                break;
+
+            case OperatorType::Toggle:
+                // No bindings
+                break;
+
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                break;
+
+            case OperatorType::DateSetNow:
+                // No bindings
+                break;
+
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayRemove:
+                $value = $values[0] ?? null;
+                $namedBindings["op_{$idx}"] = is_array($value) ? json_encode($value) : $value;
+                $idx++;
+                break;
+
+            case OperatorType::ArrayUnique:
+                // No bindings
+                break;
+
+            case OperatorType::ArrayInsert:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                $namedBindings["op_{$idx}"] = json_encode($values[1] ?? null);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
+
+            case OperatorType::ArrayFilter:
+                $condition = $values[0] ?? 'equal';
+                $filterValue = $values[1] ?? null;
+                $namedBindings["op_{$idx}"] = $condition;
+                $idx++;
+                $namedBindings["op_{$idx}"] = $filterValue !== null ? json_encode($filterValue) : null;
+                $idx++;
+                break;
         }
 
-        if (!empty($vectorDistances)) {
-            // Vector orders should come first for similarity search
-            $orders = \array_merge($vectorDistances, $orders);
+        // Replace each named binding occurrence with ? and collect positional bindings
+        // Process longest keys first to avoid partial replacement (e.g., :op_10 vs :op_1)
+        $positionalBindings = [];
+        $keys = array_keys($namedBindings);
+        usort($keys, fn ($a, $b) => strlen($b) - strlen($a));
+
+        // Find all occurrences of all named bindings and sort by position
+        $replacements = [];
+        foreach ($keys as $key) {
+            $search = ':'.$key;
+            $offset = 0;
+            while (($pos = strpos($expression, $search, $offset)) !== false) {
+                $replacements[] = ['pos' => $pos, 'len' => strlen($search), 'key' => $key];
+                $offset = $pos + strlen($search);
+            }
         }
 
-        $sqlOrder = !empty($orders) ? 'ORDER BY ' . implode(', ', $orders) : '';
-
-        $sqlLimit = '';
-        if (! \is_null($limit)) {
-            $binds[':limit'] = $limit;
-            $sqlLimit = 'LIMIT :limit';
-        }
+        // Sort by position (ascending) to replace in order
+        usort($replacements, fn ($a, $b) => $a['pos'] - $b['pos']);
 
-        if (! \is_null($offset)) {
-            $binds[':offset'] = $offset;
-            $sqlLimit .= ' OFFSET :offset';
+        // Replace from right to left to preserve positions
+        $result = $expression;
+        for ($i = count($replacements) - 1; $i >= 0; $i--) {
+            $r = $replacements[$i];
+            $result = substr_replace($result, '?', $r['pos'], $r['len']);
         }
 
-        $selections = $this->getAttributeSelections($queries);
-
-        $projection = $this->getAttributeProjection($selections, $alias);
-
-        if (!empty($vectorDistances)) {
-            $readable = $this->getSQLReadableDistance($vectorDistances[0]);
-            $projection .= ", {$readable} AS {$this->quote(static::VECTOR_DISTANCE_COLUMN)}";
+        // Collect bindings in positional order (left to right)
+        foreach ($replacements as $r) {
+            $positionalBindings[] = $namedBindings[$r['key']];
         }
 
-        $sql = "
-            SELECT {$projection}
-            FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-            {$sqlWhere}
-            {$sqlOrder}
-            {$sqlLimit};
-        ";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_FIND, $sql);
+        return ['expression' => $result, 'bindings' => $positionalBindings];
+    }
 
-        try {
-            $stmt = $this->getPDO()->prepare($sql);
+    /**
+     * Get a builder-compatible operator expression for use in upsert conflict resolution.
+     *
+     * By default this delegates to getOperatorBuilderExpression(). Adapters
+     * that need to reference the existing row differently in upsert context
+     * (e.g. Postgres using target.col) should override this method.
+     *
+     * @param  string  $column  The unquoted, filtered column name
+     * @param  Operator  $operator  The operator to convert
+     * @return array{expression: string, bindings: list<mixed>}
+     */
+    protected function getOperatorUpsertExpression(string $column, Operator $operator): array
+    {
+        return $this->getOperatorBuilderExpression($column, $operator);
+    }
 
-            foreach ($binds as $key => $value) {
-                if (gettype($value) === 'double') {
-                    $stmt->bindValue($key, $this->getFloatPrecision($value), \PDO::PARAM_STR);
-                } else {
-                    $stmt->bindValue($key, $value, $this->getPDOType($value));
+    /**
+     * Apply an operator to a value (used for new documents with only operators).
+     * This method applies the operator logic in PHP to compute what the SQL would compute.
+     *
+     * @param  mixed  $value  The current value (typically the attribute default)
+     * @return mixed The result after applying the operator
+     */
+    protected function applyOperatorToValue(Operator $operator, mixed $value): mixed
+    {
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+        $exact = BigInt::calculateOutsideNative($method, $value ?? 0, $values[0] ?? 1);
+        if ($exact !== null) {
+            $bound = $values[1] ?? null;
+            if (BigInt::isIntegerValue($bound)) {
+                $upper = \in_array($method, [OperatorType::Increment, OperatorType::Multiply, OperatorType::Power], true);
+                if (($upper && BigInt::compare($exact, $bound) > 0)
+                    || (! $upper && $method !== OperatorType::Modulo && BigInt::compare($exact, $bound) < 0)) {
+                    return BigInt::toNative($value ?? 0);
                 }
             }
 
-            $this->execute($stmt);
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
-
-        $results = $stmt->fetchAll();
-        $stmt->closeCursor();
-
-        foreach ($results as $index => $document) {
-            if (\array_key_exists('_uid', $document)) {
-                $results[$index]['$id'] = $document['_uid'];
-                unset($results[$index]['_uid']);
-            }
-            if (\array_key_exists('_id', $document)) {
-                $results[$index]['$sequence'] = $document['_id'];
-                unset($results[$index]['_id']);
-            }
-            if (\array_key_exists('_tenant', $document)) {
-                $results[$index]['$tenant'] = $document['_tenant'];
-                unset($results[$index]['_tenant']);
-            }
-            if (\array_key_exists('_createdAt', $document)) {
-                $results[$index]['$createdAt'] = $document['_createdAt'];
-                unset($results[$index]['_createdAt']);
-            }
-            if (\array_key_exists('_updatedAt', $document)) {
-                $results[$index]['$updatedAt'] = $document['_updatedAt'];
-                unset($results[$index]['_updatedAt']);
-            }
-            if (\array_key_exists('_permissions', $document)) {
-                $results[$index]['$permissions'] = \json_decode($document['_permissions'] ?? '[]', true);
-                unset($results[$index]['_permissions']);
-            }
-            if (\array_key_exists(static::VECTOR_DISTANCE_COLUMN, $document)) {
-                $value = $document[static::VECTOR_DISTANCE_COLUMN];
-                $results[$index][Database::VECTOR_DISTANCE] = \is_numeric($value) ? (float)$value : null;
-                unset($results[$index][static::VECTOR_DISTANCE_COLUMN]);
-            }
-
-            $results[$index] = new Document($results[$index]);
+            return $exact;
         }
 
-        if ($cursorDirection === Database::CURSOR_BEFORE) {
-            $results = \array_reverse($results);
-        }
+        $numVal = is_numeric($value) ? $value + 0 : 0;
+        $firstValue = count($values) > 0 ? $values[0] : null;
+        $numOp = is_numeric($firstValue) ? $firstValue + 0 : 1;
+        /** @var array<mixed> $arrVal */
+        $arrVal = is_array($value) ? $value : [];
+
+        return match ($method) {
+            OperatorType::Increment => $numVal + $numOp,
+            OperatorType::Decrement => $numVal - $numOp,
+            OperatorType::Multiply => $numVal * $numOp,
+            OperatorType::Divide => $numOp != 0 ? $numVal / $numOp : $numVal,
+            OperatorType::Modulo => $numOp != 0 ? (int) $numVal % (int) $numOp : (int) $numVal,
+            OperatorType::Power => pow($numVal, $numOp),
+            OperatorType::ArrayAppend => array_merge($arrVal, $values),
+            OperatorType::ArrayPrepend => array_merge($values, $arrVal),
+            OperatorType::ArrayInsert => (function () use ($arrVal, $values) {
+                $arr = $arrVal;
+                $insertIdxRaw = count($values) > 0 ? $values[0] : 0;
+                $insertIdx = \is_numeric($insertIdxRaw) ? (int) $insertIdxRaw : 0;
+                array_splice($arr, $insertIdx, 0, [count($values) > 1 ? $values[1] : null]);
 
-        return $results;
+                return $arr;
+            })(),
+            OperatorType::ArrayRemove => (function () use ($arrVal, $values) {
+                $arr = self::stringifyList($arrVal);
+                $toRemove = $values[0] ?? null;
+                $remove = \is_array($toRemove) ? self::stringifyList($toRemove) : [self::stringify($toRemove)];
+
+                return array_values(array_diff($arr, $remove));
+            })(),
+            OperatorType::ArrayUnique => array_values(array_unique(self::stringifyList($arrVal))),
+            OperatorType::ArrayIntersect => array_values(array_intersect(self::stringifyList($arrVal), self::stringifyList($values))),
+            OperatorType::ArrayDiff => array_values(array_diff(self::stringifyList($arrVal), self::stringifyList($values))),
+            OperatorType::ArrayFilter => $arrVal,
+            OperatorType::StringConcat => (\is_scalar($value) ? (string) $value : '') . (count($values) > 0 && \is_scalar($values[0]) ? (string) $values[0] : ''),
+            OperatorType::StringReplace => str_replace(count($values) > 0 && \is_scalar($values[0]) ? (string) $values[0] : '', count($values) > 1 && \is_scalar($values[1]) ? (string) $values[1] : '', \is_scalar($value) ? (string) $value : ''),
+            OperatorType::Toggle => ! ($value ?? false),
+            OperatorType::DateAddDays,
+            OperatorType::DateSubDays => $value,
+            OperatorType::DateSetNow => DateTime::now(),
+        };
     }
 
     /**
-     * Count Documents
-     *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $max
-     * @return int
-     * @throws Exception
-     * @throws PDOException
+     * @param  array<mixed>  $values
+     * @return list<string>
      */
-    public function count(Document $collection, array $queries = [], ?int $max = null): int
+    private static function stringifyList(array $values): array
     {
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
-        $roles = $this->authorization->getRoles();
-        $binds = [];
-        $where = [];
-        $alias = Query::DEFAULT_ALIAS;
-
-        $limit = '';
-        if (! \is_null($max)) {
-            $binds[':limit'] = $max;
-            $limit = 'LIMIT :limit';
+        $out = [];
+        foreach ($values as $value) {
+            $out[] = self::stringify($value);
         }
 
-        $queries = array_map(fn ($query) => clone $query, $queries);
+        return $out;
+    }
 
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if (!in_array($query->getMethod(), Query::VECTOR_TYPES)) {
-                $otherQueries[] = $query;
-            }
+    private static function stringify(mixed $value): string
+    {
+        if (\is_string($value)) {
+            return $value;
         }
-
-        $conditions = $this->getSQLConditionsForCollection($name, $otherQueries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
+        if (\is_scalar($value) || $value === null) {
+            return (string) $value;
         }
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias);
-        }
+        return \get_debug_type($value);
+    }
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
-        }
+    /**
+     * Quote an identifier (table name, column name) with the appropriate quoting character.
+     */
+    protected function quote(string $string): string
+    {
+        return "`{$string}`";
+    }
+
+    /**
+     * Whether the adapter requires an alias on INSERT for conflict resolution.
+     *
+     * PostgreSQL needs INSERT INTO table AS target so that the ON CONFLICT
+     * clause can reference the existing row via target.column. MariaDB does
+     * not need this because it uses VALUES(column) syntax.
+     */
+    protected function insertRequiresAlias(): bool
+    {
+        return false;
+    }
 
-        $sqlWhere = !empty($where)
-            ? 'WHERE ' . \implode(' AND ', $where)
-            : '';
+    /**
+     * Get the conflict-resolution expression for a regular column in shared-tables mode.
+     *
+     * The returned expression is used as the RHS of "col = <expression>" in the
+     * ON CONFLICT / ON DUPLICATE KEY UPDATE clause. It must conditionally update
+     * the column only when the tenant matches.
+     *
+     * @param  string  $column  The unquoted column name
+     * @return string The raw SQL expression (with positional ? placeholders if needed)
+     */
+    abstract protected function getConflictTenantExpression(string $column): string;
 
-        if (empty($limit)) {
-            $sql = "
-            SELECT COUNT(1) as sum
-			FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-			{$sqlWhere}
-        ";
-        } else {
-            $sql = "
-			SELECT COUNT(1) as sum FROM (
-				SELECT 1
-				FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-                {$sqlWhere}
-                {$limit}
-			) table_count
-        ";
-        }
+    /**
+     * Get the conflict-resolution expression for an increment column.
+     *
+     * Returns the RHS expression that adds the incoming value to the existing
+     * column value (e.g. col + VALUES(col) for MariaDB, target.col + EXCLUDED.col
+     * for Postgres).
+     *
+     * @param  string  $column  The unquoted column name
+     * @return string The raw SQL expression
+     */
+    abstract protected function getConflictIncrementExpression(string $column): string;
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_COUNT, $sql);
+    /**
+     * Get the conflict-resolution expression for an increment column in shared-tables mode.
+     *
+     * Like getConflictTenantExpression but the "new value" is the existing column
+     * value plus the incoming value.
+     *
+     * @param  string  $column  The unquoted column name
+     * @return string The raw SQL expression
+     */
+    abstract protected function getConflictTenantIncrementExpression(string $column): string;
 
-        $stmt = $this->getPDO()->prepare($sql);
+    /**
+     * Get PDO Type
+     *
+     * @throws Exception
+     */
+    protected function getPDOType(mixed $value): int
+    {
+        return match (gettype($value)) {
+            'string', 'double' => \PDO::PARAM_STR,
+            'integer', 'boolean' => \PDO::PARAM_INT,
+            'NULL' => \PDO::PARAM_NULL,
+            default => throw new DatabaseException('Unknown PDO Type for ' . \gettype($value)),
+        };
+    }
 
-        foreach ($binds as $key => $value) {
-            $stmt->bindValue($key, $value, $this->getPDOType($value));
-        }
+    /**
+     * Get the SQL function for random ordering
+     */
+    protected function getRandomOrder(): string
+    {
+        return 'RANDOM()';
+    }
 
-        try {
-            $this->execute($stmt);
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
+    /**
+     * Get SQL Operator
+     *
+     * @throws Exception
+     */
+    protected function getSQLOperator(Method $method): string
+    {
+        return match ($method) {
+            Method::Equal => '=',
+            Method::NotEqual => '!=',
+            Method::LessThan => '<',
+            Method::LessThanEqual => '<=',
+            Method::GreaterThan => '>',
+            Method::GreaterThanEqual => '>=',
+            Method::IsNull => 'IS NULL',
+            Method::IsNotNull => 'IS NOT NULL',
+            Method::StartsWith,
+            Method::EndsWith,
+            Method::Contains,
+            Method::ContainsAny,
+            Method::ContainsAll,
+            Method::NotStartsWith,
+            Method::NotEndsWith,
+            Method::NotContains => $this->getLikeOperator(),
+            Method::Regex => $this->getRegexOperator(),
+            Method::VectorDot,
+            Method::VectorCosine,
+            Method::VectorEuclidean => throw new DatabaseException('Vector queries are not supported by this database'),
+            Method::Exists,
+            Method::NotExists => throw new DatabaseException('Exists queries are not supported by this database'),
+            default => throw new DatabaseException('Unknown method: '.$method->value),
+        };
+    }
 
-        $result = $stmt->fetchAll();
-        $stmt->closeCursor();
-        if (!empty($result)) {
-            $result = $result[0];
-        }
+    /**
+     * Handle spatial queries. Adapters that support spatial types should override this.
+     *
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws DatabaseException
+     */
+    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
+    {
+        throw new DatabaseException('Spatial queries not supported');
+    }
 
-        return $result['sum'] ?? 0;
+    /**
+     * Handle distance-based spatial queries. Adapters that support spatial types should override this.
+     *
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws DatabaseException
+     */
+    protected function handleDistanceSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
+    {
+        throw new DatabaseException('Spatial queries not supported');
     }
 
     /**
-     * Sum an Attribute
+     * @param  array<string, mixed>  $binds
+     * @param  ?string  $forCollection  Filtered collection id (for FTS5 routing).
      *
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @param int|null $max
-     * @return int|float
      * @throws Exception
-     * @throws PDOException
      */
-    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): int|float
+    protected function getSQLCondition(Query $query, array &$binds, ?string $forCollection = null): string
     {
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
+
+        $attribute = $query->getAttribute();
         $attribute = $this->filter($attribute);
-        $roles = $this->authorization->getRoles();
-        $where = [];
-        $alias = Query::DEFAULT_ALIAS;
-        $binds = [];
+        $attribute = $this->quote($attribute);
+        $alias = $this->quote(Query::DEFAULT_ALIAS);
+        $placeholder = ID::unique();
 
-        $limit = '';
-        if (! \is_null($max)) {
-            $binds[':limit'] = $max;
-            $limit = 'LIMIT :limit';
+        if ($query->isSpatialAttribute()) {
+            if (! ($this instanceof Feature\Spatial)) {
+                throw new QueryException('Spatial queries not supported');
+            }
+
+            return $this->handleSpatialQueries($query, $binds, $attribute, $query->getAttributeType(), $alias, $placeholder);
         }
 
-        $queries = array_map(fn ($query) => clone $query, $queries);
+        switch ($query->getMethod()) {
+            case Method::Or:
+            case Method::And:
+                $conditions = [];
+                /** @var iterable<Query> $nestedQueries */
+                $nestedQueries = $query->getValue();
+                foreach ($nestedQueries as $q) {
+                    $conditions[] = $this->getSQLCondition($q, $binds, $forCollection);
+                }
 
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if (!in_array($query->getMethod(), Query::VECTOR_TYPES)) {
-                $otherQueries[] = $query;
-            }
-        }
+                $method = strtoupper($query->getMethod()->value);
 
-        $conditions = $this->getSQLConditionsForCollection($name, $otherQueries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
-        }
+                return empty($conditions) ? '' : ' ' . $method . ' (' . implode(' AND ', $conditions) . ')';
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias);
-        }
+            case Method::Search:
+                $searchVal = $query->getValue();
+                $fulltextValue = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
+                if ($fulltextValue === '') {
+                    return '0 = 1';
+                }
+                $binds[":{$placeholder}_0"] = $fulltextValue;
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
-        }
+                return "MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE)";
 
-        $sqlWhere = !empty($where)
-            ? 'WHERE ' . \implode(' AND ', $where)
-            : '';
+            case Method::NotSearch:
+                $notSearchVal = $query->getValue();
+                $fulltextValue = $this->getFulltextValue(\is_string($notSearchVal) ? $notSearchVal : '');
+                if ($fulltextValue === '') {
+                    return '1 = 1';
+                }
+                $binds[":{$placeholder}_0"] = $fulltextValue;
 
-        if (empty($limit)) {
-            $sql = "
-			SELECT SUM({$this->quote($attribute)}) as sum
-			FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-			{$sqlWhere}
-        ";
-        } else {
-            $sql = "
-			SELECT SUM({$this->quote($attribute)}) as sum FROM (
-				SELECT {$this->quote($attribute)}
-				FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-				{$sqlWhere}
-				{$limit}
-			) table_count
-        ";
-        }
+                return "NOT (MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE))";
 
+            case Method::Between:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_SUM, $sql);
+                return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-        $stmt = $this->getPDO()->prepare($sql);
+            case Method::NotBetween:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
 
-        foreach ($binds as $key => $value) {
-            $stmt->bindValue($key, $value, $this->getPDOType($value));
-        }
+                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-        try {
-            $this->execute($stmt);
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
+            case Method::IsNull:
+            case Method::IsNotNull:
 
-        $result = $stmt->fetchAll();
-        $stmt->closeCursor();
-        if (!empty($result)) {
-            $result = $result[0];
-        }
+                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
+            case Method::ContainsAll:
+                if ($query->onArray()) {
+                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
 
-        return $result['sum'] ?? 0;
-    }
+                    return "JSON_CONTAINS({$alias}.{$attribute}, :{$placeholder}_0)";
+                }
+                // no break
+            case Method::Contains:
+            case Method::ContainsAny:
+            case Method::NotContains:
+                if ($this->supports(Capability::JSONOverlaps) && $query->onArray()) {
+                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
+                    $isNot = $query->getMethod() === Method::NotContains;
+
+                    return $isNot
+                        ? "NOT (JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0))"
+                        : "JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0)";
+                }
+                // no break
+            default:
+                $conditions = [];
+                $isNotQuery = in_array($query->getMethod(), [
+                    Method::NotStartsWith,
+                    Method::NotEndsWith,
+                    Method::NotContains,
+                ]);
+
+                foreach ($query->getValues() as $key => $value) {
+                    $strValue = \is_string($value) ? $value : '';
+                    $value = match ($query->getMethod()) {
+                        Method::StartsWith => $this->escapeWildcards($strValue) . '%',
+                        Method::NotStartsWith => $this->escapeWildcards($strValue) . '%',
+                        Method::EndsWith => '%' . $this->escapeWildcards($strValue),
+                        Method::NotEndsWith => '%' . $this->escapeWildcards($strValue),
+                        Method::Contains, Method::ContainsAny => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($strValue) . '%',
+                        Method::NotContains => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($strValue) . '%',
+                        default => $value
+                    };
 
-    public function getSpatialTypeFromWKT(string $wkt): string
-    {
-        $wkt = trim($wkt);
-        $pos = strpos($wkt, '(');
-        if ($pos === false) {
-            throw new DatabaseException("Invalid spatial type");
+                    $binds[":{$placeholder}_{$key}"] = $value;
+                    if ($isNotQuery) {
+                        $conditions[] = "{$alias}.{$attribute} NOT {$this->getSQLOperator($query->getMethod())} :{$placeholder}_{$key}";
+                    } else {
+                        $conditions[] = "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())} :{$placeholder}_{$key}";
+                    }
+                }
+
+                $separator = $isNotQuery ? ' AND ' : ' OR ';
+
+                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
         }
-        return strtolower(trim(substr($wkt, 0, $pos)));
     }
 
-    public function decodePoint(string $wkb): array
+    /**
+     * Build a combined SQL WHERE clause from multiple query objects.
+     *
+     * @param  array<Query>  $queries
+     * @param  array<string, mixed>  $binds
+     * @param  string  $separator  The logical operator joining conditions (AND/OR)
+     * @param  ?string  $forCollection  See {@see getSQLCondition}.
+     * @return string
+     *
+     * @throws Exception
+     */
+    public function getSQLConditions(array $queries, array &$binds, string $separator = 'AND', ?string $forCollection = null): string
     {
-        if (str_starts_with(strtoupper($wkb), 'POINT(')) {
-            $start = strpos($wkb, '(') + 1;
-            $end = strrpos($wkb, ')');
-            $inside = substr($wkb, $start, $end - $start);
-            $coords = explode(' ', trim($inside));
-            return [(float)$coords[0], (float)$coords[1]];
+        $conditions = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                continue;
+            }
+
+            if ($query->isNested()) {
+                /** @var array<Query> $nestedQueries */
+                $nestedQueries = $query->getValues();
+                $conditions[] = $this->getSQLConditions($nestedQueries, $binds, strtoupper($query->getMethod()->value), $forCollection);
+            } else {
+                $conditions[] = $this->getSQLCondition($query, $binds, $forCollection);
+            }
         }
 
-        /**
-         * [0..3]   SRID (4 bytes, little-endian)
-         * [4]      Byte order (1 = little-endian, 0 = big-endian)
-         * [5..8]   Geometry type (with SRID flag bit)
-         * [9..]    Geometry payload (coordinates, etc.)
-         */
+        $tmp = implode(' '.$separator.' ', $conditions);
 
-        if (strlen($wkb) < 25) {
-            throw new DatabaseException('Invalid WKB: too short for POINT');
-        }
+        return empty($tmp) ? '' : '('.$tmp.')';
+    }
 
-        // 4 bytes SRID first → skip to byteOrder at offset 4
-        $byteOrder = ord($wkb[4]);
-        $littleEndian = ($byteOrder === 1);
+    protected function getFulltextValue(string $value): string
+    {
+        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
 
-        if (!$littleEndian) {
-            throw new DatabaseException('Only little-endian WKB supported');
-        }
+        /** Keep only unicode letters, numbers, underscores, and whitespace. */
+        $value = preg_replace('/[^\p{L}\p{N}_\s]/u', ' ', $value) ?? '';
+        $value = preg_replace('/\s+/', ' ', $value) ?? '';
+        $value = trim($value);
 
-        // After SRID (4) + byteOrder (1) + type (4) = 9 bytes
-        $coordsBin = substr($wkb, 9, 16);
-        if (strlen($coordsBin) !== 16) {
-            throw new DatabaseException('Invalid WKB: missing coordinate bytes');
+        if (empty($value)) {
+            return '';
         }
 
-        // Unpack two doubles
-        $coords = unpack('d2', $coordsBin);
-        if ($coords === false || !isset($coords[1], $coords[2])) {
-            throw new DatabaseException('Invalid WKB: failed to unpack coordinates');
+        if ($exact) {
+            $value = '"'.$value.'"';
+        } else {
+            /** Prepend wildcard by default on the back. */
+            $value .= '*';
         }
 
-        return [(float)$coords[1], (float)$coords[2]];
+        return $value;
     }
 
-    public function decodeLinestring(string $wkb): array
+    /**
+     * Get vector distance calculation for ORDER BY clause (named binds - legacy).
+     *
+     * @param  array<string, mixed>  $binds
+     */
+    protected function getVectorDistanceOrder(Query $query, array &$binds, string $alias): ?string
     {
-        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
-            $start = strpos($wkb, '(') + 1;
-            $end = strrpos($wkb, ')');
-            $inside = substr($wkb, $start, $end - $start);
+        return null;
+    }
 
-            $points = explode(',', $inside);
-            return array_map(function ($point) {
-                $coords = explode(' ', trim($point));
-                return [(float)$coords[0], (float)$coords[1]];
-            }, $points);
-        }
+    /**
+     * Get vector distance ORDER BY expression with positional bindings.
+     *
+     * Returns null when vectors are unsupported. Subclasses that support vectors
+     * should override this to return the expression string with `?` placeholders
+     * and the matching binding values.
+     *
+     * @return array{expression: string, bindings: list<mixed>}|null
+     */
+    protected function getVectorOrderRaw(Query $query, string $alias): ?array
+    {
+        return null;
+    }
 
-        // Skip 1 byte (endianness) + 4 bytes (type) + 4 bytes (SRID)
-        $offset = 9;
+    /**
+     * @param array{expression: string, bindings: list<mixed>} $vector
+     * @param list<string> $orderAttributes
+     * @param list<OrderDirection> $orderTypes
+     * @param array<string, mixed> $cursor
+     * @param callable(string): string $resolveInternalKey
+     * @return array{expression: string, bindings: list<mixed>}
+     */
+    private function getVectorCursorCondition(
+        array $vector,
+        float $distance,
+        array $orderAttributes,
+        array $orderTypes,
+        array $cursor,
+        CursorDirection $cursorDirection,
+        string $alias,
+        callable $resolveInternalKey,
+    ): array {
+        $distance = \json_encode($distance, JSON_THROW_ON_ERROR);
+        $distanceOperator = $cursorDirection === CursorDirection::Before ? '<' : '>';
+        $clauses = ["({$vector['expression']}) {$distanceOperator} ?"];
+        $bindings = [];
+        \array_push($bindings, ...$vector['bindings']);
+        $bindings[] = $distance;
+        $quotedAlias = $this->quote($alias);
 
-        // Number of points (4 bytes little-endian)
-        $numPointsArr = unpack('V', substr($wkb, $offset, 4));
-        if ($numPointsArr === false || !isset($numPointsArr[1])) {
-            throw new DatabaseException('Invalid WKB: cannot unpack number of points');
-        }
+        foreach ($orderAttributes as $index => $attribute) {
+            if (! \array_key_exists($attribute, $cursor)) {
+                throw new QueryException("Vector cursor is missing order attribute '{$attribute}'");
+            }
 
-        $numPoints = $numPointsArr[1];
-        $offset += 4;
+            $parts = ["({$vector['expression']}) = ?"];
+            $clauseBindings = [];
+            \array_push($clauseBindings, ...$vector['bindings']);
+            $clauseBindings[] = $distance;
 
-        $points = [];
-        for ($i = 0; $i < $numPoints; $i++) {
-            $xArr = unpack('d', substr($wkb, $offset, 8));
-            $yArr = unpack('d', substr($wkb, $offset + 8, 8));
+            for ($previous = 0; $previous < $index; $previous++) {
+                $previousAttribute = $orderAttributes[$previous];
+                if (! \array_key_exists($previousAttribute, $cursor)) {
+                    throw new QueryException("Vector cursor is missing order attribute '{$previousAttribute}'");
+                }
 
-            if ($xArr === false || !isset($xArr[1]) || $yArr === false || !isset($yArr[1])) {
-                throw new DatabaseException('Invalid WKB: cannot unpack point coordinates');
+                $previousColumn = $this->quote($resolveInternalKey($previousAttribute));
+                $parts[] = "{$quotedAlias}.{$previousColumn} = ?";
+                $clauseBindings[] = $cursor[$previousAttribute];
             }
 
-            $points[] = [(float)$xArr[1], (float)$yArr[1]];
-            $offset += 16;
+            $direction = $orderTypes[$index] ?? OrderDirection::Asc;
+            if ($cursorDirection === CursorDirection::Before) {
+                $direction = $direction === OrderDirection::Asc
+                    ? OrderDirection::Desc
+                    : OrderDirection::Asc;
+            }
+            $operator = $direction === OrderDirection::Desc ? '<' : '>';
+            $column = $this->quote($resolveInternalKey($attribute));
+            $parts[] = "{$quotedAlias}.{$column} {$operator} ?";
+            $clauseBindings[] = $cursor[$attribute];
+            $clauses[] = '('.\implode(' AND ', $parts).')';
+            \array_push($bindings, ...$clauseBindings);
         }
 
-        return $points;
+        return [
+            'expression' => '('.\implode(' OR ', $clauses).')',
+            'bindings' => $bindings,
+        ];
+    }
+
+    /**
+     * Render a vector distance expression in a form safe to hydrate as a PHP float.
+     */
+    protected function getSQLReadableDistance(string $distance): string
+    {
+        return $distance;
     }
 
-    public function decodePolygon(string $wkb): array
+    /**
+     * Get the SQL LIKE operator for this adapter.
+     *
+     * @return string
+     */
+    public function getLikeOperator(): string
     {
-        // POLYGON((x1,y1),(x2,y2))
-        if (str_starts_with($wkb, 'POLYGON((')) {
-            $start = strpos($wkb, '((') + 2;
-            $end = strrpos($wkb, '))');
-            $inside = substr($wkb, $start, $end - $start);
+        return 'LIKE';
+    }
 
-            $rings = explode('),(', $inside);
-            return array_map(function ($ring) {
-                $points = explode(',', $ring);
-                return array_map(function ($point) {
-                    $coords = explode(' ', trim($point));
-                    return [(float)$coords[0], (float)$coords[1]];
-                }, $points);
-            }, $rings);
-        }
+    /**
+     * Get the SQL regex matching operator for this adapter.
+     *
+     * @return string
+     */
+    public function getRegexOperator(): string
+    {
+        return 'REGEXP';
+    }
 
-        // Convert HEX string to binary if needed
-        if (str_starts_with($wkb, '0x') || ctype_xdigit($wkb)) {
-            $wkb = hex2bin(str_starts_with($wkb, '0x') ? substr($wkb, 2) : $wkb);
-            if ($wkb === false) {
-                throw new DatabaseException('Invalid hex WKB');
-            }
+    /**
+     * Get the SQL tenant filter clause for shared-table queries.
+     *
+     * @param string $collection The collection name
+     * @param string $alias Optional table alias
+     * @param int $tenantCount Number of tenant values for IN clause
+     * @param string $condition The logical condition prefix (AND/WHERE)
+     * @return string
+     *
+     * @deprecated Use TenantFilter hook with the query builder instead.
+     */
+    public function getTenantQuery(
+        string $collection,
+        string $alias = '',
+        int $tenantCount = 0,
+        string $condition = 'AND'
+    ): string {
+        if (! $this->sharedTables) {
+            return '';
         }
 
-        if (strlen($wkb) < 21) {
-            throw new DatabaseException('WKB too short to be a POLYGON');
+        $dot = '';
+        if ($alias !== '') {
+            $dot = '.';
+            $alias = $this->quote($alias);
         }
 
-        // MySQL SRID-aware WKB layout: 4 bytes SRID prefix
-        $offset = 4;
-
-        $byteOrder = ord($wkb[$offset]);
-        if ($byteOrder !== 1) {
-            throw new DatabaseException('Only little-endian WKB supported');
+        $bindings = [];
+        if ($tenantCount === 0) {
+            $bindings[] = ':'.Storage::TENANT;
+        } else {
+            for ($index = 0; $index < $tenantCount; $index++) {
+                $bindings[] = ':'.Storage::TENANT.'_'.$index;
+            }
         }
-        $offset += 1;
+        $bindings = \implode(',', $bindings);
 
-        $typeArr = unpack('V', substr($wkb, $offset, 4));
-        if ($typeArr === false || !isset($typeArr[1])) {
-            throw new DatabaseException('Invalid WKB: cannot unpack geometry type');
+        $tenant = Storage::TENANT;
+        $orIsNull = '';
+        if ($collection === Database::METADATA) {
+            $orIsNull = " OR {$alias}{$dot}{$tenant} IS NULL";
         }
 
-        $type = $typeArr[1];
-        $hasSRID = ($type & 0x20000000) === 0x20000000;
-        $geomType = $type & 0xFF;
-        $offset += 4;
+        return "{$condition} ({$alias}{$dot}{$tenant} IN ({$bindings}) {$orIsNull})";
+    }
 
-        if ($geomType !== 3) { // 3 = POLYGON
-            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
+    /**
+     * Get the SQL projection given the selected attributes
+     *
+     * @param  array<string>  $selections
+     *
+     * @throws Exception
+     */
+    protected function getAttributeProjection(array $selections, string $prefix): mixed
+    {
+        if (empty($selections) || \in_array('*', $selections)) {
+            return "{$this->quote($prefix)}.*";
         }
 
-        // Skip SRID in type flag if present
-        if ($hasSRID) {
-            $offset += 4;
-        }
+        // Handle specific selections with spatial conversion where needed
+        $internalKeys = [
+            Document::ID,
+            Document::SEQUENCE,
+            Document::PERMISSIONS,
+            Document::CREATED_AT,
+            Document::UPDATED_AT,
+        ];
 
-        $numRingsArr = unpack('V', substr($wkb, $offset, 4));
+        $selections = \array_diff($selections, [...$internalKeys, Document::COLLECTION]);
 
-        if ($numRingsArr === false || !isset($numRingsArr[1])) {
-            throw new DatabaseException('Invalid WKB: cannot unpack number of rings');
+        foreach ($internalKeys as $internalKey) {
+            $selections[] = $this->getInternalKeyForAttribute($internalKey);
         }
 
-        $numRings = $numRingsArr[1];
-        $offset += 4;
-
-        $rings = [];
-
-        for ($r = 0; $r < $numRings; $r++) {
-            $numPointsArr = unpack('V', substr($wkb, $offset, 4));
-
-            if ($numPointsArr === false || !isset($numPointsArr[1])) {
-                throw new DatabaseException('Invalid WKB: cannot unpack number of points');
-            }
-
-            $numPoints = $numPointsArr[1];
-            $offset += 4;
-            $ring = [];
-
-            for ($p = 0; $p < $numPoints; $p++) {
-                $xArr = unpack('d', substr($wkb, $offset, 8));
-                if ($xArr === false) {
-                    throw new DatabaseException('Failed to unpack X coordinate from WKB.');
-                }
-
-                $x = (float) $xArr[1];
-
-                $yArr = unpack('d', substr($wkb, $offset + 8, 8));
-                if ($yArr === false) {
-                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
-                }
+        $projections = [];
+        foreach ($selections as $selection) {
+            $filteredSelection = $this->filter($selection);
+            $quotedSelection = $this->quote($filteredSelection);
+            $projections[] = "{$this->quote($prefix)}.{$quotedSelection}";
+        }
 
-                $y = (float) $yArr[1];
+        return \implode(',', $projections);
+    }
 
-                $ring[] = [$x, $y];
-                $offset += 16;
-            }
+    protected function escapeWildcards(string $value): string
+    {
+        $wildcards = ['%', '_', '[', ']', '^', '-', '.', '*', '+', '?', '(', ')', '{', '}', '|'];
 
-            $rings[] = $ring;
+        foreach ($wildcards as $wildcard) {
+            $value = \str_replace($wildcard, "\\$wildcard", $value);
         }
 
-        return $rings;
+        return $value;
     }
 
-    public function setSupportForAttributes(bool $support): bool
+    protected function processException(PDOException $e): Exception
     {
-        return true;
+        return $e;
     }
 
-    public function getSupportForAlterLocks(): bool
+    /**
+     * Extract search queries from the query list (non-destructive).
+     *
+     * @param array<Query> $queries
+     * @return array<Query>
+     */
+    protected function extractSearchQueries(array $queries): array
     {
-        return false;
+        $searchQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Search) {
+                $searchQueries[] = $query;
+            }
+        }
+
+        return $searchQueries;
     }
 
-    public function getLockType(): string
+    /**
+     * Quote a search attribute, keeping join-qualified paths on the join alias.
+     *
+     * @return array{0: string, 1: string}
+     */
+    protected function quoteSearchAttribute(string $attribute, string $alias): array
     {
-        if ($this->getSupportForAlterLocks() && $this->alterLocks) {
-            return ',LOCK=SHARED';
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false) {
+            $prefix = \substr($attribute, 0, $dot);
+            $name = \substr($attribute, $dot + 1);
+
+            return [
+                $this->quote($this->filter($prefix)),
+                $this->quote($this->filter($this->getInternalKeyForAttribute($name))),
+            ];
         }
 
-        return '';
+        return [
+            $this->quote($alias),
+            $this->quote($this->filter($this->getInternalKeyForAttribute($attribute))),
+        ];
+    }
+
+    /**
+     * Get the raw SQL expression for full-text search relevance scoring.
+     *
+     * @return array{expression: string, order: string, bindings: list<mixed>}|null
+     */
+    protected function getSearchRelevanceRaw(Query $query, string $alias): ?array
+    {
+        return null;
     }
 
-    public function getSupportForTransactionRetries(): bool
+    /**
+     * Whether `$query` should bypass the upstream Builder pipeline and be
+     * compiled by the adapter directly via {@see compileAdapterFilter()}.
+     *
+     * Used by adapters whose query semantics aren't expressible through the
+     * Builder's typed methods — e.g. SQLite's FTS5 search needs an
+     * `IN (SELECT rowid FROM <fts_table> ...)` subquery that requires the
+     * collection name and metadata.
+     */
+    protected function isAdapterFilterQuery(Query $query): bool
     {
-        return true;
+        return false;
     }
 
-    public function getSupportForNestedTransactions(): bool
+    /**
+     * Compile an adapter-specific filter to a raw WHERE expression with
+     * positional bindings. Called for queries flagged by
+     * {@see isAdapterFilterQuery()}. Returning null skips emission.
+     *
+     * @return array{expression: string, bindings: list<mixed>}|null
+     */
+    protected function compileAdapterFilter(Query $query, string $collection, string $alias): ?array
     {
-        return true;
+        return null;
     }
 }
diff --git a/src/Database/Adapter/SQLite.php b/src/Database/Adapter/SQLite.php
index 3880aec167..2bc0ceb490 100644
--- a/src/Database/Adapter/SQLite.php
+++ b/src/Database/Adapter/SQLite.php
@@ -5,8 +5,16 @@
 use Exception;
 use PDO;
 use PDOException;
+use PDOStatement;
+use Swoole\Database\PDOProxy;
+use Swoole\Database\PDOStatementProxy;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Change;
 use Utopia\Database\Database;
+use Utopia\Database\DateTime as DatabaseDateTime;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
@@ -17,8 +25,22 @@
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Exception\Unique as UniqueException;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\PDO as DatabasePDO;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\Builder\SQLite as SQLiteBuilder;
+use Utopia\Query\Method;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 /**
  * Main differences from MariaDB and MySQL:
@@ -34,7 +56,7 @@
  * 9. MODIFY COLUMN is not supported
  * 10. Can't rename an index directly
  */
-class SQLite extends MariaDB
+class SQLite extends SQL implements Feature\SchemaAttributes, Feature\SchemaIndexes
 {
     /** Suffix appended to every FTS5 virtual table name created by this adapter. */
     private const FTS_TABLE_SUFFIX = '_fts';
@@ -48,6 +70,23 @@ class SQLite extends MariaDB
     /** AFTER UPDATE trigger suffix on the parent collection. */
     private const FTS_TRIGGER_UPDATE = 'au';
 
+    private const string INDEX_1 = '_index_1';
+
+    private const string INDEX_2 = '_index_2';
+
+    /**
+     * Reject patterns over this size to bound ReDoS exposure — the UDF runs
+     * once per candidate row, so a pathological pattern is amplified by
+     * table cardinality.
+     */
+    private const REGEXP_MAX_PATTERN_LENGTH = 512;
+
+    /**
+     * Cap on cached delimited patterns. Long-lived adapters processing many
+     * distinct user patterns would otherwise grow this map without bound.
+     */
+    private const REGEXP_PATTERN_CACHE_LIMIT = 256;
+
     /**
      * Per-collection attribute → FTS5 table memo. Populated in one pass
      * so multi-attribute SEARCH batches don't issue PRAGMA per attribute.
@@ -72,13 +111,76 @@ class SQLite extends MariaDB
      */
     private bool $pcreRegistered = false;
 
-    public function __construct(mixed $pdo)
+    public function __construct(object $pdo)
     {
         parent::__construct($pdo);
 
         $this->registerUserFunctions();
     }
 
+    protected function getPDO(): DatabasePDO|PDOProxy|PDO
+    {
+        return parent::getPDO();
+    }
+
+    /**
+     * Prepare a statement and reject drivers that return false or another
+     * non-statement value before a method is called on it.
+     */
+    private function prepare(
+        string $query,
+        string $message = 'Failed to prepare SQLite statement',
+        ?Event $event = null,
+    ): DatabasePDOStatement|PDOStatementProxy|PDOStatement {
+        try {
+            return parent::prepareStatement($query, $event);
+        } catch (DatabaseException $error) {
+            if ($error->getMessage() !== 'Failed to prepare SQL statement') {
+                throw $error;
+            }
+
+            throw new DatabaseException($message, $error->getCode(), $error);
+        }
+    }
+
+    /**
+     * Get the list of capabilities supported by the SQLite adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        $remove = [
+            Capability::Schemas,
+            Capability::Regex,
+            Capability::UpdateLock,
+            Capability::QueryContains,
+            Capability::Hostname,
+            Capability::UpsertOnUniqueIndex,
+        ];
+
+        if (! $this->emulateMySQL) {
+            $remove[] = Capability::AttributeResizing;
+        }
+
+        $extras = [
+            Capability::IntegerBooleans,
+            Capability::NumericCasting,
+        ];
+
+        if ($this->pcreRegistered) {
+            $extras[] = Capability::PCRE;
+        }
+
+        return array_merge(
+            array_values(array_filter(
+                parent::capabilities(),
+                fn (Capability $c) => ! in_array($c, $remove, true)
+            )),
+            $extras
+        );
+    }
+
     /**
      * Toggle MariaDB/MySQL emulation. See $emulateMySQL for what this
      * actually changes.
@@ -86,6 +188,8 @@ public function __construct(mixed $pdo)
     public function setEmulateMySQL(bool $emulate): static
     {
         $this->emulateMySQL = $emulate;
+        // Capability set is computed from $emulateMySQL — invalidate the cache.
+        $this->capabilitySet = null;
 
         return $this;
     }
@@ -129,19 +233,6 @@ public function setSharedTables(bool $sharedTables): bool
         return $result;
     }
 
-    /**
-     * Reject patterns over this size to bound ReDoS exposure — the UDF runs
-     * once per candidate row, so a pathological pattern is amplified by
-     * table cardinality.
-     */
-    private const REGEXP_MAX_PATTERN_LENGTH = 512;
-
-    /**
-     * Cap on cached delimited patterns. Long-lived adapters processing many
-     * distinct user patterns would otherwise grow this map without bound.
-     */
-    private const REGEXP_PATTERN_CACHE_LIMIT = 256;
-
     /**
      * Register a preg_match-backed REGEXP UDF so the inherited REGEXP
      * path resolves. Best-effort — non-SQLite PDOs simply skip it.
@@ -180,14 +271,29 @@ private function registerUserFunctions(): void
         };
 
         try {
-            $this->getPDO()->sqliteCreateFunction('REGEXP', $pcre, 2);
+            $pdo = $this->getPDO();
+            if ($pdo instanceof DatabasePDO) {
+                $pdo->__call('sqliteCreateFunction', ['REGEXP', $pcre, 2]);
+            } elseif (\method_exists($pdo, 'sqliteCreateFunction')) {
+                $pdo->sqliteCreateFunction('REGEXP', $pcre, 2);
+            }
             $this->pcreRegistered = true;
+            // Capability::PCRE is conditional on UDF registration — invalidate cache.
+            $this->capabilitySet = null;
         } catch (\Throwable) {
         }
     }
 
     /**
-     * @inheritDoc
+     * @param  PDOStatement|DatabasePDOStatement|PDOStatementProxy  $stmt
+     */
+    protected function execute(mixed $stmt, ?Event $event = null): bool
+    {
+        return $stmt->execute();
+    }
+
+    /**
+     * {@inheritDoc}
      *
      * SQLite serialises writers through a single file lock. PDO's default
      * `BEGIN` is `DEFERRED`, which acquires the writer lock lazily on the
@@ -202,24 +308,24 @@ public function startTransaction(): bool
         try {
             if ($this->inTransaction === 0) {
                 if ($this->getPDO()->inTransaction()) {
-                    $this->getPDO()
+                    $this
                         ->prepare('ROLLBACK')
                         ->execute();
                 }
 
-                $result = $this->getPDO()
+                $result = $this
                     ->prepare('BEGIN IMMEDIATE')
                     ->execute();
             } else {
-                $result = $this->getPDO()
-                    ->prepare('SAVEPOINT transaction' . $this->inTransaction)
+                $result = $this
+                    ->prepare('SAVEPOINT transaction'.$this->inTransaction)
                     ->execute();
             }
         } catch (PDOException $e) {
-            throw new TransactionException('Failed to start transaction: ' . $e->getMessage(), $e->getCode(), $e);
+            throw new TransactionException('Failed to start transaction: '.$e->getMessage(), $e->getCode(), $e);
         }
 
-        if (!$result) {
+        if (! $result) {
             throw new TransactionException('Failed to start transaction');
         }
 
@@ -245,14 +351,14 @@ public function commitTransaction(): bool
 
         try {
             if ($this->inTransaction > 1) {
-                $result = $this->getPDO()
+                $result = $this
                     ->prepare('RELEASE SAVEPOINT transaction' . ($this->inTransaction - 1))
                     ->execute();
                 $this->inTransaction--;
                 return $result;
             }
 
-            $result = $this->getPDO()
+            $result = $this
                 ->prepare('COMMIT')
                 ->execute();
             $this->inTransaction = 0;
@@ -277,12 +383,12 @@ public function rollbackTransaction(): bool
 
         try {
             if ($this->inTransaction > 1) {
-                $this->getPDO()
+                $this
                     ->prepare('ROLLBACK TO transaction' . ($this->inTransaction - 1))
                     ->execute();
                 $this->inTransaction--;
             } else {
-                $this->getPDO()
+                $this
                     ->prepare('ROLLBACK')
                     ->execute();
                 $this->inTransaction = 0;
@@ -295,13 +401,21 @@ public function rollbackTransaction(): bool
         return true;
     }
 
+    /**
+     * Create Database
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function create(string $name): bool
+    {
+        return true;
+    }
+
     /**
      * Check if Database exists
      * Optionally check if collection exists in Database
      *
-     * @param string $database
-     * @param string|null $collection
-     * @return bool
      * @throws DatabaseException
      */
     public function exists(string $database, ?string $collection = null): bool
@@ -315,45 +429,32 @@ public function exists(string $database, ?string $collection = null): bool
         $collection = $this->filter($collection);
 
         $sql = "
-			SELECT name FROM sqlite_master 
+			SELECT name FROM sqlite_master
 			WHERE type='table' AND name = :table
 		";
 
-        $sql = $this->trigger(Database::EVENT_DATABASE_CREATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
+        $stmt = $this->prepare($sql, 'Failed to prepare collection existence query', Event::CollectionRead);
 
         $stmt->bindValue(':table', "{$this->getNamespace()}_{$collection}", PDO::PARAM_STR);
 
-        $stmt->execute();
+        $this->execute($stmt);
 
         $document = $stmt->fetchAll();
         $stmt->closeCursor();
-        if (!empty($document)) {
-            $document = $document[0];
-        }
+        if (! empty($document)) {
+            /** @var array<string, mixed> $firstDoc */
+            $firstDoc = $document[0];
+            $docName = $firstDoc['name'] ?? '';
 
-        return (($document['name'] ?? '') === "{$this->getNamespace()}_{$collection}");
-    }
+            return (\is_string($docName) ? $docName : '') === "{$this->getNamespace()}_{$collection}";
+        }
 
-    /**
-     * Create Database
-     *
-     * @param string $name
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    public function create(string $name): bool
-    {
-        return true;
+        return false;
     }
 
     /**
      * Delete Database
      *
-     * @param string $name
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
@@ -365,10 +466,9 @@ public function delete(string $name): bool
     /**
      * Create Collection
      *
-     * @param string $name
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @return bool
+     * @param  array<Attribute>  $attributes
+     * @param  array<Index>  $indexes
+     *
      * @throws Exception
      * @throws PDOException
      */
@@ -380,14 +480,14 @@ public function createCollection(string $name, array $attributes = [], array $in
         $attributeStrings = [];
 
         foreach ($attributes as $key => $attribute) {
-            $attrId = $this->filter($attribute->getId());
+            $attrId = $this->filter($attribute->key);
 
             $attrType = $this->getSQLType(
-                $attribute->getAttribute('type'),
-                $attribute->getAttribute('size', 0),
-                $attribute->getAttribute('signed', true),
-                $attribute->getAttribute('array', false),
-                $attribute->getAttribute('required', false)
+                $attribute->type,
+                $attribute->size,
+                $attribute->signed,
+                $attribute->array,
+                $attribute->required
             );
 
             $attributeStrings[$key] = "`{$attrId}` {$attrType}, ";
@@ -399,103 +499,98 @@ public function createCollection(string $name, array $attributes = [], array $in
         // PRAGMA table_info echoes the exact string under emulation;
         // otherwise use INTEGER, the affinity-correct vanilla form.
         $tenantType = $this->emulateMySQL ? '"INT(11) UNSIGNED"' : 'INTEGER';
-        $tenantQuery = $this->sharedTables ? "`_tenant` {$tenantType} DEFAULT NULL," : '';
+        $tenantQuery = $this->sharedTables ? "{$this->quote(Storage::TENANT)} {$tenantType} DEFAULT NULL," : '';
 
         $collection = "
 			CREATE TABLE {$this->getSQLTable($id)} (
-				`_id` INTEGER PRIMARY KEY AUTOINCREMENT,
-				`_uid` VARCHAR(36) NOT NULL,
+				{$this->quote(Storage::SEQUENCE)} INTEGER PRIMARY KEY AUTOINCREMENT,
+				{$this->quote(Storage::UID)} VARCHAR(36) NOT NULL,
 				{$tenantQuery}
-				`_createdAt` DATETIME(3) DEFAULT NULL,
-				`_updatedAt` DATETIME(3) DEFAULT NULL,
-				`_permissions` MEDIUMTEXT DEFAULT NULL".(!empty($attributes) ? ',' : '')."
-				" . \substr(\implode(' ', $attributeStrings), 0, -2) . "
+				{$this->quote(Storage::CREATED_AT)} DATETIME(3) DEFAULT NULL,
+				{$this->quote(Storage::UPDATED_AT)} DATETIME(3) DEFAULT NULL,
+				{$this->quote(Storage::PERMISSIONS)} MEDIUMTEXT DEFAULT NULL,
+				{$this->quote(Storage::VERSION)} INTEGER DEFAULT 1".(! empty($attributes) ? ',' : '').'
+				'.\substr(\implode(' ', $attributeStrings), 0, -2).'
 			)
-		";
-
-        $collection = $this->trigger(Database::EVENT_COLLECTION_CREATE, $collection);
+		';
 
         $permissions = "
-			CREATE TABLE {$this->getSQLTable($id . '_perms')} (
-				`_id` INTEGER PRIMARY KEY AUTOINCREMENT,
+			CREATE TABLE {$this->getSQLTable(Storage::permissionsTable($id))} (
+				{$this->quote(Storage::SEQUENCE)} INTEGER PRIMARY KEY AUTOINCREMENT,
 				{$tenantQuery}
-				`_type` VARCHAR(12) NOT NULL,
-				`_permission` VARCHAR(255) NOT NULL,
-				`_document` VARCHAR(255) NOT NULL
+				{$this->quote(Storage::PERM_TYPE)} VARCHAR(12) NOT NULL,
+				{$this->quote(Storage::PERM_PERMISSION)} VARCHAR(255) NOT NULL,
+				{$this->quote(Storage::PERM_DOCUMENT)} VARCHAR(255) NOT NULL
 			)
 		";
 
-        $permissions = $this->trigger(Database::EVENT_COLLECTION_CREATE, $permissions);
-
         try {
-            $this->getPDO()
-                ->prepare($collection)
-                ->execute();
+            $this->execute($this->prepare($collection, event: Event::CollectionCreate));
 
-            $this->getPDO()
-                ->prepare($permissions)
-                ->execute();
+            $this->execute($this->prepare($permissions, event: Event::CollectionCreate));
 
-            $this->createIndex($id, '_index1', Database::INDEX_UNIQUE, ['_uid'], [], []);
-            $this->createIndex($id, '_created_at', Database::INDEX_KEY, [ '_createdAt'], [], []);
-            $this->createIndex($id, '_updated_at', Database::INDEX_KEY, [ '_updatedAt'], [], []);
+            $this->createIndex($id, Index::unique(key: Storage::INDEX_1, attributes: [Storage::UID]), event: Event::CollectionCreate);
+            $this->createIndex($id, Index::key(key: Storage::INDEX_CREATED_AT, attributes: [Storage::CREATED_AT]), event: Event::CollectionCreate);
+            $this->createIndex($id, Index::key(key: Storage::INDEX_UPDATED_AT, attributes: [Storage::UPDATED_AT]), event: Event::CollectionCreate);
 
-            $this->createIndex("{$id}_perms", '_index_1', Database::INDEX_UNIQUE, ['_document', '_type', '_permission'], [], []);
-            $this->createIndex("{$id}_perms", '_index_2', Database::INDEX_KEY, ['_permission', '_type'], [], []);
+            $this->createIndex(Storage::permissionsTable($id), Index::unique(key: self::INDEX_1, attributes: [Storage::PERM_DOCUMENT, Storage::PERM_TYPE, Storage::PERM_PERMISSION]), event: Event::CollectionCreate);
+            $this->createIndex(Storage::permissionsTable($id), Index::key(key: self::INDEX_2, attributes: [Storage::PERM_PERMISSION, Storage::PERM_TYPE]), event: Event::CollectionCreate);
 
             if ($this->sharedTables) {
-                $this->createIndex($id, '_tenant_id', Database::INDEX_KEY, [ '_id'], [], []);
+                $this->createIndex($id, Index::key(key: Storage::INDEX_TENANT_ID, attributes: [Storage::SEQUENCE]), event: Event::CollectionCreate);
             }
 
             foreach ($indexes as $index) {
-                $indexId = $this->filter($index->getId());
-                $indexType = $index->getAttribute('type');
-                $indexAttributes = $index->getAttribute('attributes', []);
-                $indexLengths = $index->getAttribute('lengths', []);
-                $indexOrders = $index->getAttribute('orders', []);
-                $indexTtl = $index->getAttribute('ttl', 0);
-
-                $this->createIndex($id, $indexId, $indexType, $indexAttributes, $indexLengths, $indexOrders, [], [], $indexTtl);
+                $this->createIndex($id, new Index(
+                    key: $this->filter($index->key),
+                    type: $index->type,
+                    attributes: $index->attributes,
+                    lengths: $index->lengths,
+                    orders: $index->orders,
+                    ttl: $index->ttl,
+                ), event: Event::CollectionCreate);
             }
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
+
         return true;
     }
 
-
     /**
      * Get Collection Size of raw data
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
      *
+     * @throws DatabaseException
      */
     public function getSizeOfCollection(string $collection): int
     {
         $collection = $this->filter($collection);
         $namespace = $this->getNamespace();
         $name = $namespace . '_' . $collection;
-        $permissions = $namespace . '_' . $collection . '_perms';
+        $permissions = $namespace . '_' . Storage::permissionsTable($collection);
         $ftsPrefix = $this->getFulltextTablePrefix($collection);
 
         // FTS5 storage lives in `<vtable>_data|_idx|_docsize|_config`
         // shadow tables; sum (pgsize - unused) over all of them.
         $ftsPattern = $this->escapeLikePattern($ftsPrefix) . '%' . $this->escapeLikePattern(self::FTS_TABLE_SUFFIX) . '%';
 
-        $stmt = $this->getPDO()->prepare("
+        $stmt = $this->prepare("
              SELECT COALESCE(SUM(\"pgsize\" - \"unused\"), 0)
              FROM \"dbstat\"
              WHERE name = :name OR name = :perms OR name LIKE :fts_pattern ESCAPE '\\';
-        ");
+        ", event: Event::CollectionRead);
 
         $stmt->bindParam(':name', $name);
         $stmt->bindParam(':perms', $permissions);
         $stmt->bindParam(':fts_pattern', $ftsPattern);
 
         try {
-            $stmt->execute();
-            $size = (int) $stmt->fetchColumn();
+            $this->execute($stmt);
+            $result = $stmt->fetchColumn();
+            if (! \is_int($result) && (! \is_string($result) || ! \is_numeric($result))) {
+                throw new DatabaseException('Failed to get collection size: invalid database result');
+            }
+            $size = (int) $result;
             $stmt->closeCursor();
         } catch (PDOException $e) {
             throw new DatabaseException('Failed to get collection size: ' . $e->getMessage());
@@ -506,8 +601,7 @@ public function getSizeOfCollection(string $collection): int
 
     /**
      * Get Collection Size on disk
-     * @param string $collection
-     * @return int
+     *
      * @throws DatabaseException
      */
     public function getSizeOfCollectionOnDisk(string $collection): int
@@ -517,8 +611,7 @@ public function getSizeOfCollectionOnDisk(string $collection): int
 
     /**
      * Delete Collection
-     * @param string $id
-     * @return bool
+     *
      * @throws Exception
      * @throws PDOException
      */
@@ -529,59 +622,32 @@ public function deleteCollection(string $id): bool
         // FTS5 shadow tables don't drop with the parent.
         foreach ($this->findFulltextTables($id) as $ftsTable) {
             $sql = "DROP TABLE IF EXISTS `{$ftsTable}`";
-            $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
-            $this->getPDO()->prepare($sql)->execute();
+            $this->execute($this->prepare($sql, event: Event::CollectionDelete));
         }
 
         $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id)}";
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
 
-        $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        $this->execute($this->prepare($sql, event: Event::CollectionDelete));
 
-        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id . '_perms')}";
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
+        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable(Storage::permissionsTable($id))}";
 
-        $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        $this->execute($this->prepare($sql, event: Event::CollectionDelete));
 
         unset($this->ftsTableCache[$id]);
 
         return true;
     }
 
-    /**
-     * Analyze a collection updating it's metadata on the database engine
-     *
-     * @param string $collection
-     * @return bool
-     */
-    public function analyzeCollection(string $collection): bool
-    {
-        return false;
-    }
-
     /**
      * Update Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $newKey
-     * @param bool $required
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function updateAttribute(string $collection, string $id, string $type, int $size, bool $signed = true, bool $array = false, ?string $newKey = null, bool $required = false): bool
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
     {
-        if (!empty($newKey) && $newKey !== $id) {
-            return $this->renameAttribute($collection, $id, $newKey);
+        if (! empty($newKey) && $newKey !== $attribute->key) {
+            return $this->renameAttribute($collection, $attribute->key, $newKey);
         }
 
         // SQLite is dynamically typed — `ALTER TABLE ... MODIFY COLUMN` is
@@ -590,32 +656,32 @@ public function updateAttribute(string $collection, string $id, string $type, in
         // raise the same TruncateException MariaDB throws. Off-
         // emulation the declared size is metadata-only, so skip the
         // scan and let the rename branch (if any) handle the rest.
-        if ($this->emulateMySQL && $type === Database::VAR_STRING && $size > 0 && !$array) {
+        if ($this->emulateMySQL && $attribute->type === ColumnType::String && $attribute->size > 0 && ! $attribute->array) {
             $name = $this->filter($collection);
-            $column = $this->filter($id);
+            $column = $this->filter($attribute->key);
 
             // Under shared tables the underlying table is shared across
             // tenants; scoping the scan by `_tenant` keeps tenant A's
             // resize from being blocked (and tenant A's metadata from
             // leaking) by an oversized value owned by tenant B.
-            $tenantClause = $this->sharedTables ? ' AND `_tenant` = :_tenant' : '';
+            $tenantClause = $this->sharedTables ? ' AND '.$this->quote(Storage::TENANT).' = :'.Storage::TENANT : '';
             $sql = "SELECT 1 FROM {$this->getSQLTable($name)} WHERE LENGTH(`{$column}`) > :max{$tenantClause} LIMIT 1";
 
-            $stmt = $this->getPDO()->prepare($sql);
-            $stmt->bindValue(':max', $size, PDO::PARAM_INT);
+            $stmt = $this->prepare($sql, event: Event::AttributeUpdate);
+            $stmt->bindValue(':max', $attribute->size, PDO::PARAM_INT);
             if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant, \is_int($this->tenant) ? PDO::PARAM_INT : PDO::PARAM_STR);
+                $stmt->bindValue(':'.Storage::TENANT, $this->tenant, \is_int($this->tenant) ? PDO::PARAM_INT : PDO::PARAM_STR);
             }
 
             try {
-                $stmt->execute();
+                $this->execute($stmt);
                 $exceeds = $stmt->fetchColumn() !== false;
             } finally {
                 $stmt->closeCursor();
             }
 
             if ($exceeds) {
-                throw new TruncateException("Attribute '{$id}' has values exceeding new size {$size}");
+                throw new TruncateException("Attribute '{$attribute->key}' has values exceeding new size {$attribute->size}");
             }
         }
 
@@ -625,47 +691,47 @@ public function updateAttribute(string $collection, string $id, string $type, in
     /**
      * Delete Attribute
      *
-     * @param string $collection
-     * @param string $id
-     * @param bool $array
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function deleteAttribute(string $collection, string $id, bool $array = false): bool
+    public function deleteAttribute(string $collection, string $id): bool
     {
         $name = $this->filter($collection);
         $id = $this->filter($id);
-        $metadataCollection = new Document(['$id' => Database::METADATA]);
+        $metadataCollection = new Document([Document::ID => Database::METADATA]);
         $collection = $this->getDocument($metadataCollection, $name);
 
         if ($collection->isEmpty()) {
             throw new NotFoundException('Collection not found');
         }
 
-        $indexes = $collection->getAttribute('indexes', []);
-        if (\is_string($indexes)) {
-            $indexes = \json_decode($indexes, true) ?? [];
-        }
+        $rawIndexes = $collection->getAttribute('indexes', '[]');
+        /** @var array<int, array<string, mixed>> $indexes */
+        $indexes = \json_decode(\is_string($rawIndexes) ? $rawIndexes : '[]', true) ?? [];
 
         foreach ($indexes as $index) {
-            $attributes = $index['attributes'];
+            /** @var array<string, mixed> $index */
+            $attributes = $index['attributes'] ?? [];
+            $indexId = \is_string($index[Document::ID] ?? null) ? (string) $index[Document::ID] : '';
+            $indexType = \is_string($index['type'] ?? null) ? (string) $index['type'] : '';
             if ($attributes === [$id]) {
-                $this->deleteIndex($name, $index['$id']);
-            } elseif (\in_array($id, $attributes)) {
-                $this->deleteIndex($name, $index['$id']);
-                $this->createIndex($name, $index['$id'], $index['type'], \array_diff($attributes, [$id]), $index['lengths'], $index['orders']);
+                $this->deleteIndex($name, $indexId, Event::AttributeDelete);
+            } elseif (\in_array($id, \is_array($attributes) ? $attributes : [])) {
+                $this->deleteIndex($name, $indexId, Event::AttributeDelete);
+                $this->createIndex($name, Index::fromArray([
+                    'key' => $indexId,
+                    'type' => $indexType,
+                    'attributes' => \array_map(fn (mixed $v): string => \is_scalar($v) ? (string) $v : '', \is_array($attributes) ? \array_values(\array_filter($attributes, fn ($v) => $v !== $id)) : []),
+                    'lengths' => \array_map(fn (mixed $v): int => \is_numeric($v) ? (int) $v : 0, \is_array($index['lengths'] ?? null) ? $index['lengths'] : []),
+                    'orders' => \is_array($index['orders'] ?? null) ? $index['orders'] : [],
+                ]), event: Event::AttributeDelete);
             }
         }
 
         $sql = "ALTER TABLE {$this->getSQLTable($name)} DROP COLUMN `{$id}`";
 
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
-
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            return $this->execute($this->prepare($sql, event: Event::AttributeDelete));
         } catch (PDOException $e) {
             if (str_contains($e->getMessage(), 'no such column')) {
                 return true;
@@ -675,99 +741,47 @@ public function deleteAttribute(string $collection, string $id, bool $array = fa
         }
     }
 
-    /**
-     * Rename Index
-     *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    public function renameIndex(string $collection, string $old, string $new): bool
-    {
-        $metadataCollection = new Document(['$id' => Database::METADATA]);
-        $collection = $this->getDocument($metadataCollection, $collection);
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $old = $this->filter($old);
-        $new = $this->filter($new);
-        $indexes = $collection->getAttribute('indexes', []);
-        if (\is_string($indexes)) {
-            $indexes = \json_decode($indexes, true) ?? [];
-        }
-        $index = null;
-
-        foreach ($indexes as $node) {
-            if ($node['key'] === $old) {
-                $index = $node;
-                break;
-            }
-        }
-
-        if ($index
-            && $this->deleteIndex($collection->getId(), $old)
-            && $this->createIndex(
-                $collection->getId(),
-                $new,
-                $index['type'],
-                $index['attributes'],
-                $index['lengths'],
-                $index['orders'],
-            )) {
-            return true;
-        }
-
-        return false;
-    }
-
     /**
      * Create Index
      *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param array<string,string> $indexAttributeTypes
-     * @return bool
+     * @param  array<string,string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
+     *
      * @throws Exception
      * @throws PDOException
      */
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths, array $orders, array $indexAttributeTypes = [], array $collation = [], int $ttl = 1): bool
-    {
+    public function createIndex(
+        string $collection,
+        Index $index,
+        array $indexAttributeTypes = [],
+        array $collation = [],
+        Event $event = Event::IndexCreate,
+    ): bool {
         $name = $this->filter($collection);
-        $id = $this->filter($id);
+        $id = $this->filter($index->key);
+        $type = $index->type;
+        $attributes = $index->attributes;
 
-        if ($type === Database::INDEX_FULLTEXT) {
-            return $this->createFulltextIndex($name, $id, $attributes);
+        if ($type === IndexType::Fulltext) {
+            return $this->createFulltextIndex($name, $id, $attributes, $event);
         }
 
         // Workaround for no support for CREATE INDEX IF NOT EXISTS
-        $stmt = $this->getPDO()->prepare("
+        $stmt = $this->prepare("
 			SELECT name
 			FROM sqlite_master
 			WHERE type='index' AND name=:_index;
-		");
+			", event: $event);
         $stmt->bindValue(':_index', "{$this->getNamespace()}_{$this->getTenantSegment()}_{$name}_{$id}");
-        $stmt->execute();
-        $index = $stmt->fetch();
-        if (!empty($index)) {
+        $this->execute($stmt);
+        $existingIndex = $stmt->fetch();
+        if (! empty($existingIndex)) {
             return true;
         }
 
         $sql = $this->getSQLIndex($name, $id, $type, $attributes);
 
-        $sql = $this->trigger(Database::EVENT_INDEX_CREATE, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+        return $this->execute($this->prepare($sql, event: $event));
     }
 
     /**
@@ -777,7 +791,7 @@ public function createIndex(string $collection, string $id, string $type, array
      * @param array<string> $attributes
      * @throws PDOException
      */
-    protected function createFulltextIndex(string $collection, string $id, array $attributes): bool
+    protected function createFulltextIndex(string $collection, string $id, array $attributes, Event $event = Event::IndexCreate): bool
     {
         if (empty($attributes)) {
             throw new DatabaseException('Fulltext index requires at least one attribute');
@@ -787,13 +801,13 @@ protected function createFulltextIndex(string $collection, string $id, array $at
         $ftsTable = $this->getFulltextTableName($collection, $attributes);
         $parentTable = "{$this->getNamespace()}_{$collection}";
 
-        $stmt = $this->getPDO()->prepare("
+        $stmt = $this->prepare("
             SELECT name
             FROM sqlite_master
             WHERE type='table' AND name=:_table;
-        ");
+        ", event: $event);
         $stmt->bindValue(':_table', $ftsTable);
-        $stmt->execute();
+        $this->execute($stmt);
         $exists = !empty($stmt->fetch());
         $stmt->closeCursor();
         if ($exists) {
@@ -811,47 +825,46 @@ protected function createFulltextIndex(string $collection, string $id, array $at
         // literal — otherwise tenant A's vtable accumulates tenant B's
         // tokenized content. The same applies to the initial backfill.
         $tenantLiteral = $this->sharedTables ? $this->getTenantSqlLiteral() : null;
-        $insertWhen = $tenantLiteral !== null ? " WHEN NEW.`_tenant` IS {$tenantLiteral}" : '';
-        $deleteWhen = $tenantLiteral !== null ? " WHEN OLD.`_tenant` IS {$tenantLiteral}" : '';
+        $insertWhen = $tenantLiteral !== null ? " WHEN NEW.{$this->quote(Storage::TENANT)} IS {$tenantLiteral}" : '';
+        $deleteWhen = $tenantLiteral !== null ? " WHEN OLD.{$this->quote(Storage::TENANT)} IS {$tenantLiteral}" : '';
         $updateWhen = $tenantLiteral !== null
-            ? " WHEN OLD.`_tenant` IS {$tenantLiteral} OR NEW.`_tenant` IS {$tenantLiteral}"
+            ? " WHEN OLD.{$this->quote(Storage::TENANT)} IS {$tenantLiteral} OR NEW.{$this->quote(Storage::TENANT)} IS {$tenantLiteral}"
             : '';
-        $backfillWhere = $tenantLiteral !== null ? " WHERE `_tenant` IS {$tenantLiteral}" : '';
+        $backfillWhere = $tenantLiteral !== null ? " WHERE {$this->quote(Storage::TENANT)} IS {$tenantLiteral}" : '';
 
         $this->startTransaction();
         try {
-            $createSql = "CREATE VIRTUAL TABLE `{$ftsTable}` USING fts5({$ftsColumnList}, content=\"{$parentTable}\", content_rowid=\"_id\")";
-            $createSql = $this->trigger(Database::EVENT_INDEX_CREATE, $createSql);
-            $this->getPDO()->prepare($createSql)->execute();
+            $createSql = "CREATE VIRTUAL TABLE `{$ftsTable}` USING fts5({$ftsColumnList}, content=\"{$parentTable}\", content_rowid=\"".Storage::SEQUENCE.'")';
+            $this->execute($this->prepare($createSql, event: $event));
 
             $insertSuffix = self::FTS_TRIGGER_INSERT;
             $insertTrigger = "
                 CREATE TRIGGER `{$ftsTable}_{$insertSuffix}` AFTER INSERT ON `{$parentTable}`{$insertWhen} BEGIN
-                    INSERT INTO `{$ftsTable}` (rowid, {$columnList}) VALUES (NEW.`_id`, {$newColumnList});
+                    INSERT INTO `{$ftsTable}` (rowid, {$columnList}) VALUES (NEW.{$this->quote(Storage::SEQUENCE)}, {$newColumnList});
                 END
             ";
-            $this->getPDO()->prepare($insertTrigger)->execute();
+            $this->execute($this->prepare($insertTrigger, event: $event));
 
             $deleteSuffix = self::FTS_TRIGGER_DELETE;
             $deleteTrigger = "
                 CREATE TRIGGER `{$ftsTable}_{$deleteSuffix}` AFTER DELETE ON `{$parentTable}`{$deleteWhen} BEGIN
-                    INSERT INTO `{$ftsTable}` (`{$ftsTable}`, rowid, {$columnList}) VALUES ('delete', OLD.`_id`, {$oldColumnList});
+                    INSERT INTO `{$ftsTable}` (`{$ftsTable}`, rowid, {$columnList}) VALUES ('delete', OLD.{$this->quote(Storage::SEQUENCE)}, {$oldColumnList});
                 END
             ";
-            $this->getPDO()->prepare($deleteTrigger)->execute();
+            $this->execute($this->prepare($deleteTrigger, event: $event));
 
             $updateSuffix = self::FTS_TRIGGER_UPDATE;
             // OF <cols>: skip re-tokenise when only timestamps/permissions change.
             $updateTrigger = "
                 CREATE TRIGGER `{$ftsTable}_{$updateSuffix}` AFTER UPDATE OF {$columnList} ON `{$parentTable}`{$updateWhen} BEGIN
-                    INSERT INTO `{$ftsTable}` (`{$ftsTable}`, rowid, {$columnList}) VALUES ('delete', OLD.`_id`, {$oldColumnList});
-                    INSERT INTO `{$ftsTable}` (rowid, {$columnList}) VALUES (NEW.`_id`, {$newColumnList});
+                    INSERT INTO `{$ftsTable}` (`{$ftsTable}`, rowid, {$columnList}) VALUES ('delete', OLD.{$this->quote(Storage::SEQUENCE)}, {$oldColumnList});
+                    INSERT INTO `{$ftsTable}` (rowid, {$columnList}) VALUES (NEW.{$this->quote(Storage::SEQUENCE)}, {$newColumnList});
                 END
             ";
-            $this->getPDO()->prepare($updateTrigger)->execute();
+            $this->execute($this->prepare($updateTrigger, event: $event));
 
-            $backfill = "INSERT INTO `{$ftsTable}` (rowid, {$columnList}) SELECT `_id`, {$columnList} FROM `{$parentTable}`{$backfillWhere}";
-            $this->getPDO()->prepare($backfill)->execute();
+            $backfill = "INSERT INTO `{$ftsTable}` (rowid, {$columnList}) SELECT {$this->quote(Storage::SEQUENCE)}, {$columnList} FROM `{$parentTable}`{$backfillWhere}";
+            $this->execute($this->prepare($backfill, event: $event));
 
             $this->commitTransaction();
         } catch (\Throwable $e) {
@@ -921,19 +934,24 @@ private function getTenantSqlLiteral(): string
             return (string) $this->tenant;
         }
 
-        return $this->getPDO()->quote((string) $this->tenant);
+        $pdo = $this->getPDO();
+        $quoted = $pdo instanceof PDOProxy
+            ? $pdo->__call('quote', [(string) $this->tenant])
+            : $pdo->quote((string) $this->tenant);
+        if (! \is_string($quoted)) {
+            throw new DatabaseException('Failed to quote SQLite tenant');
+        }
+
+        return $quoted;
     }
 
     /**
      * Delete Index
      *
-     * @param string $collection
-     * @param string $id
-     * @return bool
      * @throws Exception
      * @throws PDOException
      */
-    public function deleteIndex(string $collection, string $id): bool
+    public function deleteIndex(string $collection, string $id, Event $event = Event::IndexDelete): bool
     {
         $name = $this->filter($collection);
         $id = $this->filter($id);
@@ -943,11 +961,11 @@ public function deleteIndex(string $collection, string $id): bool
         // table (whose name is keyed off attributes, not the id) or
         // already absent — try the FTS5 path before erroring.
         $regularIndex = "{$this->getNamespace()}_{$this->getTenantSegment()}_{$name}_{$id}";
-        $stmt = $this->getPDO()->prepare("
+        $stmt = $this->prepare("
             SELECT name FROM sqlite_master WHERE type='index' AND name=:_index
-        ");
+        ", event: $event);
         $stmt->bindValue(':_index', $regularIndex);
-        $stmt->execute();
+        $this->execute($stmt);
         $hasRegular = $stmt->fetchColumn() !== false;
         // Free the read cursor before issuing DDL — SQLite holds a SHARED
         // lock on the database while a statement has unfetched rows, and
@@ -955,17 +973,14 @@ public function deleteIndex(string $collection, string $id): bool
         // will trip "database table is locked".
         $stmt->closeCursor();
 
-        if (!$hasRegular && $this->dropFulltextIndexById($name, $id)) {
+        if (! $hasRegular && $this->dropFulltextIndexById($name, $id, $event)) {
             return true;
         }
 
         $sql = "DROP INDEX `{$regularIndex}`";
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
 
         try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
+            return $this->execute($this->prepare($sql, event: $event));
         } catch (PDOException $e) {
             if (str_contains($e->getMessage(), 'no such index')) {
                 return true;
@@ -975,11 +990,61 @@ public function deleteIndex(string $collection, string $id): bool
         }
     }
 
+    /**
+     * Rename Index
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function renameIndex(string $collection, string $old, string $new): bool
+    {
+        $metadataCollection = new Document([Document::ID => Database::METADATA]);
+        $collection = $this->getDocument($metadataCollection, $collection);
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        $old = $this->filter($old);
+        $new = $this->filter($new);
+        $rawIdxs = $collection->getAttribute('indexes', '[]');
+        /** @var array<int, array<string, mixed>> $indexes */
+        $indexes = \json_decode(\is_string($rawIdxs) ? $rawIdxs : '[]', true) ?? [];
+        /** @var array<string, mixed>|null $index */
+        $index = null;
+
+        foreach ($indexes as $node) {
+            /** @var array<string, mixed> $node */
+            if (($node['key'] ?? null) === $old) {
+                $index = $node;
+                break;
+            }
+        }
+
+        if ($index
+            && $this->deleteIndex($collection->getId(), $old, Event::IndexRename)
+            && $this->createIndex(
+                $collection->getId(),
+                Index::fromArray([
+                    'key' => $new,
+                    'type' => \is_string($index['type'] ?? null) ? (string) $index['type'] : '',
+                    'attributes' => \array_map(fn (mixed $v): string => \is_scalar($v) ? (string) $v : '', \is_array($index['attributes'] ?? null) ? $index['attributes'] : []),
+                    'lengths' => \array_map(fn (mixed $v): int => \is_numeric($v) ? (int) $v : 0, \is_array($index['lengths'] ?? null) ? $index['lengths'] : []),
+                    'orders' => \is_array($index['orders'] ?? null) ? $index['orders'] : [],
+                ]),
+                event: Event::IndexRename,
+            )) {
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Drop the FTS5 vtable backing index `$id` on `$collection`. Returns
      * false when no FTS5 table exists; throws when ambiguous.
      */
-    protected function dropFulltextIndexById(string $collection, string $id): bool
+    protected function dropFulltextIndexById(string $collection, string $id, Event $event = Event::IndexDelete): bool
     {
         $tables = $this->findFulltextTables($collection);
 
@@ -1017,11 +1082,10 @@ protected function dropFulltextIndexById(string $collection, string $id): bool
         $this->startTransaction();
         try {
             foreach ($triggerSuffixes as $suffix) {
-                $this->getPDO()->prepare("DROP TRIGGER IF EXISTS `{$ftsTable}_{$suffix}`")->execute();
+                $this->execute($this->prepare("DROP TRIGGER IF EXISTS `{$ftsTable}_{$suffix}`", event: $event));
             }
             $sql = "DROP TABLE IF EXISTS `{$ftsTable}`";
-            $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
-            $this->getPDO()->prepare($sql)->execute();
+            $this->execute($this->prepare($sql, event: $event));
             $this->commitTransaction();
         } catch (\Throwable $e) {
             try {
@@ -1036,7 +1100,6 @@ protected function dropFulltextIndexById(string $collection, string $id): bool
         return true;
     }
 
-
     /**
      * Resolve the FTS5 table for index `$id` via metadata. Returns null
      * when metadata doesn't reach a candidate.
@@ -1046,7 +1109,7 @@ protected function dropFulltextIndexById(string $collection, string $id): bool
     protected function resolveFulltextTableById(string $collection, string $id, array $candidates): ?string
     {
         try {
-            $metadataCollection = new Document(['$id' => Database::METADATA]);
+            $metadataCollection = new Document([Document::ID => Database::METADATA]);
             $collectionDoc = $this->getDocument($metadataCollection, $collection);
         } catch (NotFoundException) {
             // Metadata not yet seeded (collection drop during bootstrap).
@@ -1063,12 +1126,16 @@ protected function resolveFulltextTableById(string $collection, string $id, arra
         $indexes = $collectionDoc->getAttribute('indexes', []);
         $filteredId = $this->filter($id);
 
+        if (! \is_array($indexes)) {
+            return null;
+        }
+
         foreach ($indexes as $index) {
             $indexId = $index instanceof Document
                 ? $index->getId()
-                : (\is_array($index) ? ($index['$id'] ?? null) : null);
+                : (\is_array($index) ? ($index[Document::ID] ?? null) : null);
 
-            if ($indexId === null) {
+            if (! \is_scalar($indexId)) {
                 continue;
             }
             if ($this->filter((string) $indexId) !== $filteredId) {
@@ -1077,19 +1144,23 @@ protected function resolveFulltextTableById(string $collection, string $id, arra
 
             $type = $index instanceof Document
                 ? $index->getAttribute('type')
-                : ($index['type'] ?? null);
+                : (\is_array($index) ? ($index['type'] ?? null) : null);
 
-            if ($type !== Database::INDEX_FULLTEXT) {
+            if ($type !== IndexType::Fulltext->value) {
                 return null;
             }
 
-            $attributes = $index instanceof Document
-                ? $index->getAttribute('attributes', [])
-                : ($index['attributes'] ?? []);
+            if ($index instanceof Document) {
+                $attributes = $index->getAttribute('attributes', []);
+            } else {
+                $attributes = $index['attributes'] ?? [];
+            }
 
+            /** @var array<mixed> $attributesArr */
+            $attributesArr = \is_array($attributes) ? $attributes : [];
             $internal = \array_map(
-                fn (string $a) => $this->getInternalKeyForAttribute($a),
-                (array) $attributes
+                fn (mixed $a): string => \is_string($a) ? $this->getInternalKeyForAttribute($a) : '',
+                $attributesArr
             );
             $candidate = $this->getFulltextTableName($collection, $internal);
 
@@ -1108,7 +1179,7 @@ protected function findFulltextTables(string $collection): array
     {
         // ESCAPE '\\' so the literal `_` separators in the prefix don't
         // act as LIKE wildcards (e.g. `db_users_` matching `db_usersA_`).
-        $stmt = $this->getPDO()->prepare("
+        $stmt = $this->prepare("
             SELECT name FROM sqlite_master
             WHERE type='table'
               AND name LIKE :_prefix ESCAPE '\\'
@@ -1120,7 +1191,7 @@ protected function findFulltextTables(string $collection): array
         $tables = $stmt->fetchAll(PDO::FETCH_COLUMN);
         $stmt->closeCursor();
 
-        return $tables;
+        return \array_map(fn (mixed $t): string => \is_string($t) ? $t : '', $tables);
     }
 
     /**
@@ -1136,566 +1207,149 @@ private function escapeLikePattern(string $value): string
     /**
      * Create Document
      *
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
      * @throws Exception
      * @throws PDOException
      * @throws DuplicateException
      */
     public function createDocument(Document $collection, Document $document): Document
     {
-        $collection = $collection->getId();
-        $attributes = $document->getAttributes();
-        $attributes['_createdAt'] = $document->getCreatedAt();
-        $attributes['_updatedAt'] = $document->getUpdatedAt();
-        $attributes['_permissions'] = json_encode($document->getPermissions());
-
-        if ($this->sharedTables) {
-            $attributes['_tenant'] = $this->tenant;
-        }
-
-        $name = $this->filter($collection);
-        $columns = ['_uid'];
-        $values = ['_uid'];
-
-        /**
-         * Insert Attributes
-         */
-        $bindIndex = 0;
-        foreach ($attributes as $attribute => $value) { // Parse statement
-            $column = $this->filter($attribute);
-            $values[] = 'value_' . $bindIndex;
-            $columns[] = "`{$column}`";
-            $bindIndex++;
-        }
-
-        // Insert manual id if set
-        if (!empty($document->getSequence())) {
-            $values[] = '_id';
-            $columns[] = "_id";
-        }
-
-        $sql = "
-			INSERT INTO `{$this->getNamespace()}_{$name}` (".\implode(', ', $columns).") 
-			VALUES (:".\implode(', :', $values).");
-		";
+        try {
+            $this->syncWriteHooks();
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_CREATE, $sql);
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = json_encode($document->getPermissions());
 
-        $stmt = $this->getPDO()->prepare($sql);
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
+            }
 
-        $stmt->bindValue(':_uid', $document->getId(), PDO::PARAM_STR);
+            $name = $this->filter($collection);
 
-        // Bind internal id if set
-        if (!empty($document->getSequence())) {
-            $stmt->bindValue(':_id', $document->getSequence(), PDO::PARAM_STR);
-        }
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+            $row = [Storage::UID => $document->getId()];
 
-        $attributeIndex = 0;
-        foreach ($attributes as $attribute => $value) {
-            if (is_array($value)) { // arrays & objects should be saved as strings
-                $value = json_encode($value);
+            if (! empty($document->getSequence())) {
+                $row[Storage::SEQUENCE] = $document->getSequence();
             }
 
-            $bindKey = 'value_' . $attributeIndex;
-            $attribute = $this->filter($attribute);
-            $value = (is_bool($value)) ? (int)$value : $value;
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $attributeIndex++;
-        }
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
 
-        $permissions = [];
-        foreach (Database::PERMISSIONS as $type) {
-            foreach ($document->getPermissionsByType($type) as $permission) {
-                $permission = \str_replace('"', '', $permission);
-                $tenantQuery = $this->sharedTables ? ', :_tenant' : '';
-                $permissions[] = "('{$type}', '{$permission}', '{$document->getId()}' {$tenantQuery})";
+                if (is_array($value)) {
+                    $value = json_encode($value);
+                }
+                $value = (is_bool($value)) ? (int) $value : $value;
+                $row[$column] = $value;
             }
-        }
-
-        if (!empty($permissions)) {
-            $tenantQuery = $this->sharedTables ? ', _tenant' : '';
 
-            $queryPermissions = "
-				INSERT INTO `{$this->getNamespace()}_{$name}_perms` (_type, _permission, _document {$tenantQuery})
-				VALUES " . \implode(', ', $permissions);
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
 
-            $queryPermissions = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $queryPermissions);
+            $this->execute($stmt);
 
-            $stmtPermissions = $this->getPDO()->prepare($queryPermissions);
+            $statment = $this->prepare('SELECT last_insert_rowid() AS id', event: Event::DocumentCreate);
+            $this->execute($statment);
+            $last = $statment->fetch();
 
-            if ($this->sharedTables) {
-                $stmtPermissions->bindValue(':_tenant', $this->tenant);
+            if (\is_array($last)) {
+                /** @var array<string, mixed> $last */
+                $document[Document::SEQUENCE] = $last['id'] ?? null;
             }
-        }
 
-        try {
-            $stmt->execute();
-
-            $document['$sequence'] = (int) $this->getPDO()->lastInsertId();
-
-            if (isset($stmtPermissions)) {
-                $stmtPermissions->execute();
-            }
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, [$document], $ctx));
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
 
-
         return $document;
     }
 
     /**
      * Update Document
      *
-     * @param Document $collection
-     * @param string $id
-     * @param Document $document
-     * @param bool $skipPermissions
-     * @return Document
      * @throws Exception
      * @throws PDOException
      * @throws DuplicateException
      */
     public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        $spatialAttributes = $this->getSpatialAttributes($collection);
-        $collection = $collection->getId();
-        $attributes = $document->getAttributes();
-        $attributes['_createdAt'] = $document->getCreatedAt();
-        $attributes['_updatedAt'] = $document->getUpdatedAt();
-        $attributes['_permissions'] = json_encode($document->getPermissions());
-        $attributes['_uid'] = $document->getId();
-
-        if ($this->sharedTables) {
-            $attributes['_tenant'] = $document->getTenant();
-        }
-
-        $name = $this->filter($collection);
-        $columns = '';
-
-        if (!$skipPermissions) {
-            $newUid = $document->offsetExists('$id') ? $document->getId() : $id;
+        try {
+            $this->syncWriteHooks();
+
+            $spatialAttributes = $this->getSpatialAttributes($collection);
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes[Storage::CREATED_AT] = $document->getCreatedAt();
+            $attributes[Storage::UPDATED_AT] = $document->getUpdatedAt();
+            $attributes[Storage::PERMISSIONS] = json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes[Storage::VERSION] = $version;
+            }
 
-            $sql = "
-			DELETE FROM `{$this->getNamespace()}_{$name}_perms`
-			WHERE _document = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+            $name = $this->filter($collection);
 
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
+            $operators = [];
+            foreach ($attributes as $attribute => $value) {
+                if (Operator::isOperator($value)) {
+                    $operators[$attribute] = $value;
+                }
+            }
 
-            $stmtRemovePermissions = $this->getPDO()->prepare($sql);
-            $stmtRemovePermissions->bindValue(':_uid', $id);
-            if ($this->sharedTables) {
-                $stmtRemovePermissions->bindValue(':_tenant', $document->getTenant());
+            $builder = $this->newBuilder($name);
+            $regularRow = [];
+            if (\strcasecmp($document->getId(), $id) !== 0) {
+                $regularRow[Storage::UID] = $document->getId();
             }
 
-            $values = [];
-            $binds = [];
-            foreach (Database::PERMISSIONS as $type) {
-                foreach ($document->getPermissionsByType($type) as $i => $permission) {
-                    $tenantQuery = $this->sharedTables ? ', :_tenant' : '';
-                    $values[] = "(:_uid, '{$type}', :_add_{$type}_{$i} {$tenantQuery})";
-                    $binds[":_add_{$type}_{$i}"] = $permission;
+            foreach ($attributes as $attribute => $value) {
+                $column = $this->filter($attribute);
+
+                if (isset($operators[$attribute])) {
+                    $op = $operators[$attribute];
+                    if ($op instanceof Operator) {
+                        $opResult = $this->getOperatorBuilderExpression($column, $op);
+                        $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
+                    }
+                } elseif ($this instanceof Feature\Spatial && \in_array($attribute, $spatialAttributes, true)) {
+                    if (\is_array($value)) {
+                        $value = $this->convertArrayToWKT($value);
+                    }
+                    $value = (is_bool($value)) ? (int) $value : $value;
+                    $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$value]);
+                } else {
+                    if (is_array($value)) {
+                        $value = json_encode($value);
+                    }
+                    $value = (is_bool($value)) ? (int) $value : $value;
+                    $regularRow[$column] = $value;
                 }
             }
 
-            if (!empty($values)) {
-                $tenantQuery = $this->sharedTables ? ', _tenant' : '';
-
-                $sql = "
-			   INSERT INTO `{$this->getNamespace()}_{$name}_perms` (_document, _type, _permission {$tenantQuery})
-			   VALUES " . \implode(', ', $values);
+            $builder->set($regularRow);
+            $builder->filter([BaseQuery::equal(Storage::UID, [$id])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
+            $this->execute($stmt);
 
-                $stmtAddPermissions = $this->getPDO()->prepare($sql);
-                $stmtAddPermissions->bindValue(":_uid", $newUid);
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(":_tenant", $document->getTenant());
-                }
-
-                foreach ($binds as $key => $permission) {
-                    $stmtAddPermissions->bindValue($key, $permission);
-                }
-            }
-        }
-
-        /**
-         * Update Attributes
-         */
-        $keyIndex = 0;
-        $operatorBinds = [];
-
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
-
-            // Check if this is an operator, spatial attribute, or regular attribute
-            if (Operator::isOperator($value)) {
-                $operatorSQL = $this->getOperatorSQL($column, $value, $operatorBinds);
-                $columns .= $operatorSQL;
-            } elseif ($this->getSupportForSpatialAttributes() && \in_array($attribute, $spatialAttributes, true)) {
-                $bindKey = 'key_' . $keyIndex;
-                $columns .= "`{$column}` = " . $this->getSpatialGeomFromText(':' . $bindKey);
-                $keyIndex++;
-            } else {
-                $bindKey = 'key_' . $keyIndex;
-                $columns .= "`{$column}`" . '=:' . $bindKey;
-                $keyIndex++;
-            }
-
-            $columns .= ',';
-        }
-
-        // Remove trailing comma
-        $columns = rtrim($columns, ',');
-
-        $sql = "
-			UPDATE `{$this->getNamespace()}_{$name}`
-			SET {$columns}
-			WHERE _uid = :_existingUid
-			{$this->getTenantQuery($collection)}
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        $stmt->bindValue(':_existingUid', $id);
-
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
-        }
-
-        // Bind values for non-operator attributes and operator parameters
-        $keyIndex = 0;
-        foreach ($attributes as $attribute => $value) {
-            // Handle operators separately
-            if (Operator::isOperator($value)) {
-                continue;
-            }
-
-            // Convert spatial arrays to WKT, json_encode non-spatial arrays
-            if (\in_array($attribute, $spatialAttributes, true)) {
-                if (\is_array($value)) {
-                    $value = $this->convertArrayToWKT($value);
-                }
-            } elseif (is_array($value)) { // arrays & objects should be saved as strings
-                $value = json_encode($value);
-            }
-
-            $bindKey = 'key_' . $keyIndex;
-            $value = (is_bool($value)) ? (int)$value : $value;
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $keyIndex++;
-        }
-
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
-        }
-
-        try {
-            $stmt->execute();
-            if (isset($stmtRemovePermissions)) {
-                $stmtRemovePermissions->execute();
-            }
-            if (isset($stmtAddPermissions)) {
-                $stmtAddPermissions->execute();
-            }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
+            $ctx = $this->buildWriteContext($name, $id);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpdate($name, $document, $skipPermissions, $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
 
         return $document;
     }
 
-
-
-    /**
-     * Is schemas supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemas(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForQueryContains(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is fulltext index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextIndex(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        // FTS5's unicode61 tokenizer strips characters like `@` and `.`
-        // before indexing, so a search for "al@ba.io" applied as a prefix
-        // wildcard ("al ba io*") matches a doc containing "al@ba.io" the
-        // same way the non-wildcard branch does. The upstream test gates
-        // its expectations on this flag and the false branch matches
-        // SQLite's actual tokenisation behaviour; flagging as true would
-        // claim a behavioural distinction we don't deliver.
-        return false;
-    }
-
-    /**
-     * Are timeouts supported?
-     *
-     * @return bool
-     */
-    public function getSupportForTimeouts(): bool
-    {
-        // The adapter does no per-query timeout enforcement and therefore
-        // can't translate a tripped budget into Utopia\Database\Exception\Timeout
-        // the way MariaDB/Postgres do. Stay false rather than mislead callers
-        // that rely on Database::setTimeout() actually firing.
-        return false;
-    }
-
-    public function getSupportForRelationships(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpdateLock(): bool
-    {
-        // SQLite has no row-level locking. The parser accepts FOR UPDATE
-        // as syntactic sugar but the planner still escalates to a
-        // RESERVED/EXCLUSIVE lock on the database, which deadlocks
-        // subsequent DDL like DROP INDEX inside the same transaction.
-        // Stay false so the SELECT path doesn't append the clause.
-        return false;
-    }
-
-    /**
-     * Is attribute resizing supported?
-     *
-     * @return bool
-     */
-    public function getSupportForAttributeResizing(): bool
-    {
-        // SQLite is dynamically typed with no MODIFY COLUMN. When
-        // emulating MySQL, updateAttribute scans the column on
-        // resize-down and raises TruncateException to match MariaDB's
-        // contract. Off-emulation, declared sizes are metadata-only.
-        return $this->emulateMySQL;
-    }
-
-    /**
-     * Is get connection id supported?
-     *
-     * @return bool
-     */
-    public function getSupportForGetConnectionId(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is get schema attributes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Is upsert supported?
-     *
-     * @return bool
-     */
-    public function getSupportForUpserts(): bool
-    {
-        // ON CONFLICT DO UPDATE is native SQLite, not MariaDB emulation.
-        return true;
-    }
-
-    /**
-     * SQLite has no JSON_OVERLAPS — fall back to the LIKE-based default
-     * inherited from MariaDB::getSQLCondition for CONTAINS queries on arrays.
-     */
-    public function getSupportForJSONOverlaps(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUpsertOnUniqueIndex(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is hostname supported?
-     *
-     * @return bool
-     */
-    public function getSupportForHostname(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is batch create attributes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return false; // SQLite doesn't have native spatial support
-    }
-
-    public function getSupportForObject(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUnsignedBigInt(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Are object (JSON) indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return false; // SQLite doesn't have native spatial support
-    }
-
-    /**
-     * Override getSpatialGeomFromText to return placeholder unchanged for SQLite
-     * SQLite does not support ST_GeomFromText, so we return the raw placeholder
-     *
-     * @param string $wktPlaceholder
-     * @param int|null $srid
-     * @return string
-     */
-    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
-    {
-        return $wktPlaceholder;
-    }
-
-    /**
-     * Get SQL Index Type
-     *
-     * @param string $type
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLIndexType(string $type): string
-    {
-        switch ($type) {
-            case Database::INDEX_KEY:
-                return 'INDEX';
-
-            case Database::INDEX_UNIQUE:
-                return 'UNIQUE INDEX';
-
-            case Database::INDEX_FULLTEXT:
-                // Fulltext is handled via FTS5 virtual tables in
-                // createFulltextIndex; reaching this codepath means a
-                // caller bypassed that route and would emit invalid SQL.
-                throw new DatabaseException('Fulltext indexes use createFulltextIndex(), not getSQLIndexType');
-
-            default:
-                throw new DatabaseException('Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT);
-        }
-    }
-
-    /**
-     * Get SQL Index
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLIndex(string $collection, string $id, string $type, array $attributes): string
-    {
-        $postfix = '';
-
-        switch ($type) {
-            case Database::INDEX_KEY:
-                $type = 'INDEX';
-                break;
-
-            case Database::INDEX_UNIQUE:
-                $type = 'UNIQUE INDEX';
-                $postfix = 'COLLATE NOCASE';
-
-                break;
-
-            default:
-                throw new DatabaseException('Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT);
-        }
-
-        $attributes = \array_map(fn ($attribute) => $this->getInternalKeyForAttribute($attribute), $attributes);
-
-        foreach ($attributes as $key => $attribute) {
-            $attribute = $this->filter($attribute);
-
-            $attributes[$key] = "`{$attribute}` {$postfix}";
-        }
-
-        $key = "`{$this->getNamespace()}_{$this->getTenantSegment()}_{$collection}_{$id}`";
-        $attributes = implode(', ', $attributes);
-
-        if ($this->sharedTables) {
-            $attributes = "`_tenant` {$postfix}, {$attributes}";
-        }
-
-        return "CREATE {$type} {$key} ON `{$this->getNamespace()}_{$collection}` ({$attributes})";
-    }
-
-    /**
-     * Get SQL table
-     *
-     * @param string $name
-     * @return string
-     */
-    protected function getSQLTable(string $name): string
-    {
-        return $this->quote("{$this->getNamespace()}_{$this->filter($name)}");
-    }
-
     /**
      * Get list of keywords that cannot be used
      *  Refference: https://www.sqlite.org/lang_keywords.html
@@ -1855,7 +1509,251 @@ public function getKeywords(): array
         ];
     }
 
-    protected function processException(PDOException $e): \Exception
+    protected function createBuilder(): SQLBuilder
+    {
+        return new SQLiteBuilder();
+    }
+
+    protected function getSQLType(ColumnType $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    {
+        if (in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+            return '';
+        }
+        if ($array === true) {
+            return 'JSON';
+        }
+
+        if ($type === ColumnType::String) {
+            if ($size > 16777215) {
+                return 'LONGTEXT';
+            }
+            if ($size > 65535) {
+                return 'MEDIUMTEXT';
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                return 'TEXT';
+            }
+
+            return "VARCHAR({$size})";
+        }
+
+        if ($type === ColumnType::Varchar) {
+            if ($size <= 0) {
+                throw new DatabaseException('VARCHAR size '.$size.' is invalid; must be > 0. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                throw new DatabaseException('VARCHAR size '.$size.' exceeds maximum varchar length '.$this->getMaxVarcharLength().'. Use TEXT, MEDIUMTEXT, or LONGTEXT instead.');
+            }
+
+            return "VARCHAR({$size})";
+        }
+
+        if (\in_array($type, [ColumnType::Integer, ColumnType::BigInteger, ColumnType::BigSerial], true)) {
+            $suffix = $signed ? '' : ' UNSIGNED';
+
+            return ($type === ColumnType::Integer && $size < 8 ? 'INT' : 'BIGINT').$suffix;
+        }
+
+        if ($type === ColumnType::Float || $type === ColumnType::Double) {
+            return 'DOUBLE'.($signed ? '' : ' UNSIGNED');
+        }
+
+        return match ($type) {
+            ColumnType::Id => 'BIGINT UNSIGNED',
+            ColumnType::Text => 'TEXT',
+            ColumnType::MediumText => 'MEDIUMTEXT',
+            ColumnType::LongText => 'LONGTEXT',
+            ColumnType::Boolean => 'TINYINT(1)',
+            ColumnType::Relationship => 'VARCHAR(255)',
+            ColumnType::Datetime => 'DATETIME(3)',
+            default => throw new DatabaseException('Unknown type: '.$type->value.'. Must be one of '.ColumnType::String->value.', '.ColumnType::Varchar->value.', '.ColumnType::Text->value.', '.ColumnType::MediumText->value.', '.ColumnType::LongText->value.', '.ColumnType::Integer->value.', '.ColumnType::Double->value.', '.ColumnType::Boolean->value.', '.ColumnType::Datetime->value.', '.ColumnType::Relationship->value),
+        };
+    }
+
+    protected function getMaxPointSize(): int
+    {
+        return 0;
+    }
+
+    /**
+     * Override getSpatialGeomFromText to return placeholder unchanged for SQLite
+     * SQLite does not support ST_GeomFromText, so we return the raw placeholder
+     */
+    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
+    {
+        return $wktPlaceholder;
+    }
+
+    /**
+     * Get SQL Index Type
+     *
+     * @throws Exception
+     */
+    protected function getSQLIndexType(IndexType $type): string
+    {
+        return match ($type) {
+            IndexType::Key => 'INDEX',
+            IndexType::Unique => 'UNIQUE INDEX',
+            default => throw new DatabaseException('Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value),
+        };
+    }
+
+    /**
+     * Get SQL Index
+     *
+     * @param  array<string>  $attributes
+     *
+     * @throws Exception
+     */
+    protected function getSQLIndex(string $collection, string $id, IndexType $type, array $attributes): string
+    {
+        [$sqlType, $postfix] = match ($type) {
+            IndexType::Key => ['INDEX', ''],
+            IndexType::Unique => ['UNIQUE INDEX', 'COLLATE NOCASE'],
+            default => throw new DatabaseException('Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value),
+        };
+
+        $attributes = \array_map(fn ($attribute) => match ($attribute) {
+            Document::ID => ID::custom(Storage::UID),
+            Document::CREATED_AT => Storage::CREATED_AT,
+            Document::UPDATED_AT => Storage::UPDATED_AT,
+            default => $attribute
+        }, $attributes);
+
+        foreach ($attributes as $key => $attribute) {
+            $attribute = $this->filter($attribute);
+
+            $attributes[$key] = "`{$attribute}` {$postfix}";
+        }
+
+        $key = "`{$this->getNamespace()}_{$this->tenant}_{$collection}_{$id}`";
+        $attributes = implode(', ', $attributes);
+
+        if ($this->sharedTables) {
+            $attributes = "{$this->quote(Storage::TENANT)} {$postfix}, {$attributes}";
+        }
+
+        return "CREATE {$sqlType} {$key} ON `{$this->getNamespace()}_{$collection}` ({$attributes})";
+    }
+
+    /**
+     * Get SQL table
+     */
+    protected function getSQLTable(string $name): string
+    {
+        return $this->quote("{$this->getNamespace()}_{$this->filter($name)}");
+    }
+
+    /**
+     * SQLite doesn't use database-qualified table names.
+     */
+    protected function getSQLTableRaw(string $name): string
+    {
+        return $this->getNamespace().'_'.$this->filter($name);
+    }
+
+    /**
+     * Check if SQLite math functions (like POWER) are available
+     * SQLite must be compiled with -DSQLITE_ENABLE_MATH_FUNCTIONS
+     */
+    private function getSupportForMathFunctions(): bool
+    {
+        static $available = null;
+
+        if ($available !== null) {
+            return (bool) $available;
+        }
+
+        try {
+            // Test if POWER function exists by attempting to use it
+            $pdo = $this->getPDO();
+            $stmt = $pdo instanceof PDOProxy
+                ? $pdo->__call('query', ['SELECT POWER(2, 3) as test'])
+                : $pdo->query('SELECT POWER(2, 3) as test');
+            if (! $stmt instanceof PDOStatement && ! $stmt instanceof PDOStatementProxy) {
+                $available = false;
+
+                return false;
+            }
+            $result = $stmt->fetch();
+            /** @var array<string, mixed>|false $result */
+            $testVal = \is_array($result) ? ($result['test'] ?? null) : null;
+            $available = ($testVal == 8);
+
+            return $available;
+        } catch (PDOException $e) {
+            // Function doesn't exist
+            $available = false;
+
+            return false;
+        }
+    }
+
+    protected function getSearchRelevanceRaw(Query $query, string $alias): ?array
+    {
+        return null;
+    }
+
+    #[\Override]
+    protected function isAdapterFilterQuery(Query $query): bool
+    {
+        $method = $query->getMethod();
+
+        return $method === Method::Search || $method === Method::NotSearch;
+    }
+
+    /**
+     * Compile a Search/NotSearch query into FTS5 SQL with positional bindings.
+     * Falls back to a LIKE expression when no FTS5 table covers the attribute.
+     *
+     * @return array{expression: string, bindings: list<mixed>}|null
+     */
+    #[\Override]
+    protected function compileAdapterFilter(Query $query, string $collection, string $alias): ?array
+    {
+        $method = $query->getMethod();
+        if ($method !== Method::Search && $method !== Method::NotSearch) {
+            return null;
+        }
+
+        $rawAttribute = $query->getAttribute();
+        [$quotedAlias, $quotedAttribute] = $this->quoteSearchAttribute($rawAttribute, $alias);
+
+        $rawValue = '';
+        $queryValue = $query->getValue();
+        if (\is_scalar($queryValue)) {
+            $rawValue = (string) $queryValue;
+        }
+        $ftsValue = $this->getFTS5Value($rawValue);
+
+        if ($ftsValue === '') {
+            return [
+                'expression' => $method === Method::Search ? '1 = 0' : '1 = 1',
+                'bindings' => [],
+            ];
+        }
+
+        $ftsTable = $this->findFulltextTableForAttribute($collection, $rawAttribute);
+
+        if ($ftsTable === null) {
+            $likeExpr = "{$quotedAlias}.{$quotedAttribute} LIKE ? ESCAPE '\\'";
+            $likeBinding = '%' . $this->escapeWildcards($rawValue) . '%';
+
+            return [
+                'expression' => $method === Method::Search ? $likeExpr : "NOT ({$likeExpr})",
+                'bindings' => [$likeBinding],
+            ];
+        }
+
+        $subquery = "{$quotedAlias}.{$this->quote(Storage::SEQUENCE)} IN (SELECT rowid FROM `{$ftsTable}` WHERE `{$ftsTable}` MATCH ?)";
+
+        return [
+            'expression' => $method === Method::Search ? $subquery : "NOT ({$subquery})",
+            'bindings' => [$ftsValue],
+        ];
+    }
+
+    protected function processException(PDOException $e): Exception
     {
         // Timeout
         if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 3024) {
@@ -1888,9 +1786,10 @@ protected function processException(PDOException $e): \Exception
                 stripos($message, 'duplicate') !== false
             ) {
                 $columns = $this->getViolatedColumns($message);
-                if ($columns !== null && $columns !== ['_uid'] && $columns !== ['_tenant', '_uid']) {
+                if ($columns !== null && $columns !== [Storage::UID] && $columns !== [Storage::TENANT, Storage::UID]) {
                     return new UniqueException('Unique index violation', $e->getCode(), $e);
                 }
+
                 return new DuplicateException('Document already exists', $e->getCode(), $e);
             }
         }
@@ -1904,11 +1803,7 @@ protected function processException(PDOException $e): \Exception
     }
 
     /**
-     * Extract the violated columns from a constraint error, e.g.
-     * "UNIQUE constraint failed: movies._tenant, movies._uid" resolves to
-     * ['_tenant', '_uid']. Returns null when the message cannot be parsed.
-     *
-     * @return array<string>|null
+     * @return list<string>|null
      */
     protected function getViolatedColumns(string $message): ?array
     {
@@ -1930,87 +1825,108 @@ protected function getViolatedColumns(string $message): ?array
         return $columns;
     }
 
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return false;
-    }
-    public function getSupportForBoundaryInclusiveContains(): bool
-    {
-        return false;
-    }
-
     /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
-     *
-     * @return bool
+     * Bind operator parameters to statement
+     * Override to handle SQLite-specific operator bindings
      */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
+    protected function bindOperatorParams(PDOStatement|DatabasePDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
     {
-        return false;
-    }
+        $method = $operator->getMethod();
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+        // For operators that SQLite doesn't use bind parameters for, skip binding entirely
+        // Note: The bindIndex increment happens in getOperatorSQL(), NOT here
+        if (in_array($method, [OperatorType::Toggle, OperatorType::DateSetNow, OperatorType::ArrayUnique])) {
+            // These operators don't bind any parameters - they're handled purely in SQL
+            // DO NOT increment bindIndex here as it's already handled in getOperatorSQL()
+            return;
+        }
+
+        // For ARRAY_FILTER, bind the filter value if present
+        if ($method === OperatorType::ArrayFilter) {
+            $values = $operator->getValues();
+            if (! empty($values) && count($values) >= 2) {
+                $filterType = $values[0];
+                $filterValue = $values[1];
+
+                // Only bind if we support this filter type (all comparison operators need binding)
+                $comparisonTypes = ['equal', 'notEqual', 'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual'];
+                if (in_array($filterType, $comparisonTypes)) {
+                    $bindKey = "op_{$bindIndex}";
+                    $value = (is_bool($filterValue)) ? (int) $filterValue : $filterValue;
+                    $stmt->bindValue(":{$bindKey}", $value, $this->getPDOType($value));
+                    $bindIndex++;
+                }
+            }
 
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
-     */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return true;
-    }
+            return;
+        }
 
-    /**
-     * Get the SQL function for random ordering
-     *
-     * @return string
-     */
-    protected function getRandomOrder(): string
-    {
-        return 'RANDOM()';
+        // For all other operators, use parent implementation
+        parent::bindOperatorParams($stmt, $operator, $bindIndex);
     }
 
     /**
-     * Check if SQLite math functions (like POWER) are available
-     * SQLite must be compiled with -DSQLITE_ENABLE_MATH_FUNCTIONS
-     *
-     * @return bool
+     * {@inheritDoc}
      */
-    private function getSupportForMathFunctions(): bool
+    protected function getOperatorBuilderExpression(string $column, Operator $operator): array
     {
-        static $available = null;
+        if ($operator->getMethod() === OperatorType::ArrayFilter) {
+            $bindIndex = 0;
+            $fullExpression = $this->getOperatorSQL($column, $operator, $bindIndex);
 
-        if ($available !== null) {
-            return $available;
-        }
+            if ($fullExpression === null) {
+                throw new DatabaseException('Operator cannot be expressed in SQL: '.$operator->getMethod()->value);
+            }
 
-        try {
-            // Test if POWER function exists by attempting to use it
-            $stmt = $this->getPDO()->query('SELECT POWER(2, 3) as test');
-            $result = $stmt->fetch();
-            $available = ($result['test'] == 8);
-            return $available;
-        } catch (PDOException $e) {
-            // Function doesn't exist
-            $available = false;
-            return false;
+            $quotedColumn = $this->quote($column);
+            $prefix = $quotedColumn.' = ';
+            $expression = $fullExpression;
+            if (str_starts_with($expression, $prefix)) {
+                $expression = substr($expression, strlen($prefix));
+            }
+
+            // SQLite ArrayFilter only uses one binding (the filter value), not the condition string
+            $values = $operator->getValues();
+            $namedBindings = [];
+            if (count($values) >= 2) {
+                $filterType = $values[0];
+                $comparisonTypes = ['equal', 'notEqual', 'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual'];
+                if (in_array($filterType, $comparisonTypes)) {
+                    $namedBindings['op_0'] = $values[1];
+                }
+            }
+
+            // Replace named bindings with positional
+            $positionalBindings = [];
+            $replacements = [];
+            foreach (array_keys($namedBindings) as $key) {
+                $search = ':'.$key;
+                $offset = 0;
+                while (($pos = strpos($expression, $search, $offset)) !== false) {
+                    $replacements[] = ['pos' => $pos, 'len' => strlen($search), 'key' => $key];
+                    $offset = $pos + strlen($search);
+                }
+            }
+            usort($replacements, fn ($a, $b) => $a['pos'] - $b['pos']);
+            $result = $expression;
+            for ($i = count($replacements) - 1; $i >= 0; $i--) {
+                $r = $replacements[$i];
+                $result = substr_replace($result, '?', $r['pos'], $r['len']);
+            }
+            foreach ($replacements as $r) {
+                $positionalBindings[] = $namedBindings[$r['key']] ?? null;
+            }
+
+            return ['expression' => $result, 'bindings' => $positionalBindings];
         }
+
+        return parent::getOperatorBuilderExpression($column, $operator);
     }
 
     /**
      * Get SQL expression for operator
      *
      * IMPORTANT: SQLite JSON Limitations
-     * -----------------------------------
      * Array operators using json_each() and json_group_array() have type conversion behavior:
      * - Numbers are preserved but may lose precision (e.g., 1.0 becomes 1)
      * - Booleans become integers (true→1, false→0)
@@ -2019,150 +1935,153 @@ private function getSupportForMathFunctions(): bool
      *
      * This is inherent to SQLite's JSON implementation and affects: ARRAY_APPEND, ARRAY_PREPEND,
      * ARRAY_UNIQUE, ARRAY_INTERSECT, ARRAY_DIFF, ARRAY_INSERT, and ARRAY_REMOVE.
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param array<string, mixed> $binds
-     * @return ?string
      */
-    protected function getOperatorSQL(string $column, Operator $operator, array &$binds): ?string
+    protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
         $quotedColumn = $this->quote($column);
         $method = $operator->getMethod();
+        $values = $operator->getValues();
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Increment:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
-                        WHEN COALESCE({$quotedColumn}, 0) + :$bindKey > :$maxKey THEN COALESCE({$quotedColumn}, 0)
+                        WHEN COALESCE({$quotedColumn}, 0) > :$maxKey - :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) + :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Decrement:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
-                        WHEN COALESCE({$quotedColumn}, 0) - :$bindKey < :$minKey THEN COALESCE({$quotedColumn}, 0)
+                        WHEN COALESCE({$quotedColumn}, 0) < :$minKey + :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) - :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Multiply:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
-                        WHEN COALESCE({$quotedColumn}, 0) * :$bindKey > :$maxKey THEN COALESCE({$quotedColumn}, 0)
+                        WHEN :$bindKey > 0 AND COALESCE({$quotedColumn}, 0) > :$maxKey / :$bindKey THEN COALESCE({$quotedColumn}, 0)
+                        WHEN :$bindKey < 0 AND COALESCE({$quotedColumn}, 0) < :$maxKey / :$bindKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) * :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Divide:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 if (isset($values[1])) {
-                    $minKey = $this->registerOperatorBind($binds, $values[1]);
+                    $minKey = "op_{$bindIndex}";
+                    $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN :$bindKey != 0 AND COALESCE({$quotedColumn}, 0) / :$bindKey < :$minKey THEN COALESCE({$quotedColumn}, 0)
                         ELSE COALESCE({$quotedColumn}, 0) / :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 1);
+            case OperatorType::Modulo:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) % :$bindKey";
 
-            case Operator::TYPE_POWER:
-                if (!$this->getSupportForMathFunctions()) {
+            case OperatorType::Power:
+                if (! $this->getSupportForMathFunctions()) {
                     throw new DatabaseException(
-                        'SQLite POWER operator requires math functions. ' .
+                        'SQLite POWER operator requires math functions. '.
                         'Compile SQLite with -DSQLITE_ENABLE_MATH_FUNCTIONS or use multiply operators instead.'
                     );
                 }
 
-                $values = $operator->getValues();
                 $exponent = $values[0] ?? 1;
-                $bindKey = $this->registerOperatorBind($binds, $exponent);
+                if (! \is_int($exponent) && ! \is_float($exponent)) {
+                    throw new OperatorException('Power exponent must be numeric');
+                }
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 if (isset($values[1])) {
-                    $maxKey = $this->registerOperatorBind($binds, $values[1]);
-                    $col = "COALESCE({$quotedColumn}, 0)";
+                    $maxKey = "op_{$bindIndex}";
+                    $bindIndex++;
 
-                    // Leave the value unchanged only for undefined inputs, then apply the power if
-                    // the result stays within the max. The exponent is constant, so only the
-                    // undefined guard its value can actually trigger is emitted.
+                    $columnValue = "COALESCE({$quotedColumn}, 0)";
                     $oddInteger = \floor($exponent) == $exponent && ((int) $exponent) % 2 !== 0;
+                    $guards = [];
 
-                    $whens = [];
                     if ($exponent < 0) {
-                        // 0 to a negative power is undefined.
-                        $whens[] = "WHEN {$col} = 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} = 0 THEN {$columnValue}";
                     }
                     if (\floor($exponent) != $exponent) {
-                        // A negative base to a fractional exponent is not a real number.
-                        $whens[] = "WHEN {$col} < 0 THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} < 0 THEN {$columnValue}";
                     }
-                    // Cap by magnitude via logarithms so POWER() never runs on a value that would
-                    // overflow (base^exp > max  <=>  exp * LN(base) > LN(max)).
                     if ($exponent == 0) {
-                        // Every base to the zeroth power is 1 (including 0^0), which the magnitude
-                        // check below can't see for a base of 0. The result 1 exceeds the max when
-                        // max < 1, i.e. LN(max) < 0 (LN also coerces the bound value numerically).
-                        $whens[] = "WHEN LN(:$maxKey) < 0 THEN {$col}";
+                        $guards[] = "WHEN LN(:$maxKey) < 0 THEN {$columnValue}";
                     } elseif ($oddInteger) {
-                        // An odd exponent keeps a negative base negative, and a negative result is
-                        // always within a positive max, so only cap positive bases; negative bases
-                        // fall through to POWER() and their (negative) result is applied.
-                        $whens[] = "WHEN {$col} > 0 AND :$bindKey * LN({$col}) > LN(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} > 0 AND :$bindKey * LN({$columnValue}) > LN(:$maxKey) THEN {$columnValue}";
                     } else {
-                        // Otherwise the result is non-negative, so its magnitude equals its value —
-                        // cap either sign. ABS() keeps LN() defined for a negative even-power base.
-                        $whens[] = "WHEN {$col} <> 0 AND :$bindKey * LN(ABS({$col})) > LN(:$maxKey) THEN {$col}";
+                        $guards[] = "WHEN {$columnValue} <> 0 AND :$bindKey * LN(ABS({$columnValue})) > LN(:$maxKey) THEN {$columnValue}";
                     }
 
-                    $whenSql = \implode(' ', $whens);
-                    return "{$quotedColumn} = CASE {$whenSql} ELSE POWER({$col}, :$bindKey) END";
+                    return "{$quotedColumn} = CASE ".\implode(' ', $guards)." ELSE POWER({$columnValue}, :$bindKey) END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? '');
+            case OperatorType::StringConcat:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL({$quotedColumn}, '') || :$bindKey";
 
-            case Operator::TYPE_STRING_REPLACE:
-                $values = $operator->getValues();
-                $searchKey = $this->registerOperatorBind($binds, $values[0] ?? '');
-                $replaceKey = $this->registerOperatorBind($binds, $values[1] ?? '');
+            case OperatorType::StringReplace:
+                $searchKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $replaceKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 return "{$quotedColumn} = REPLACE({$quotedColumn}, :$searchKey, :$replaceKey)";
 
                 // Boolean operators
-            case Operator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 // SQLite: toggle boolean (0 or 1), treat NULL as 0
                 return "{$quotedColumn} = CASE WHEN COALESCE({$quotedColumn}, 0) = 0 THEN 1 ELSE 0 END";
 
                 // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayAppend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: merge arrays by using json_group_array on extracted elements
                 // We use json_each to extract elements from both arrays and combine them
                 return "{$quotedColumn} = (
@@ -2174,9 +2093,10 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     )
                 )";
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayPrepend:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: prepend by extracting and recombining with new elements first
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -2187,21 +2107,17 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     )
                 )";
 
-            case Operator::TYPE_ARRAY_UNIQUE:
+            case OperatorType::ArrayUnique:
                 // SQLite: get distinct values from JSON array
                 return "{$quotedColumn} = (
                     SELECT json_group_array(DISTINCT value)
                     FROM json_each(IFNULL({$quotedColumn}, '[]'))
                 )";
 
-            case Operator::TYPE_ARRAY_REMOVE:
-                $values = $operator->getValues();
-                $removeValue = $values[0] ?? null;
-                // Cast scalars to string so the value binds as PDO::PARAM_STR, preserving the
-                // pre-refactor behavior (it was bound with an explicit PARAM_STR). Without the
-                // cast, getPDOType() would bind a number as PARAM_INT. Do not drop it.
-                $removeValue = is_array($removeValue) ? json_encode($removeValue) : (string)$removeValue;
-                $bindKey = $this->registerOperatorBind($binds, $removeValue);
+            case OperatorType::ArrayRemove:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: remove specific value from array
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -2209,10 +2125,12 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     WHERE value != :$bindKey
                 )";
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $values = $operator->getValues();
-                $indexKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
-                $valueKey = $this->registerOperatorBind($binds, json_encode($values[1] ?? null));
+            case OperatorType::ArrayInsert:
+                $indexKey = "op_{$bindIndex}";
+                $bindIndex++;
+                $valueKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: Insert element at specific index by:
                 // 1. Take elements before index (0 to index-1)
                 // 2. Add new element
@@ -2242,9 +2160,10 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     )
                 )";
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayIntersect:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: keep only values that exist in both arrays
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -2252,9 +2171,10 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     WHERE value IN (SELECT value FROM json_each(:$bindKey))
                 )";
 
-            case Operator::TYPE_ARRAY_DIFF:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, json_encode($values));
+            case OperatorType::ArrayDiff:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
+
                 // SQLite: remove values that exist in the comparison array
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -2262,7 +2182,7 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                     WHERE value NOT IN (SELECT value FROM json_each(:$bindKey))
                 )";
 
-            case Operator::TYPE_ARRAY_FILTER:
+            case OperatorType::ArrayFilter:
                 $values = $operator->getValues();
                 if (empty($values)) {
                     // No filter criteria, return array unchanged
@@ -2298,9 +2218,8 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                             return "{$quotedColumn} = {$quotedColumn}";
                         }
 
-                        $filterValue = $values[1];
-                        $filterValue = (is_bool($filterValue)) ? (int)$filterValue : $filterValue;
-                        $bindKey = $this->registerOperatorBind($binds, $filterValue);
+                        $bindKey = "op_{$bindIndex}";
+                        $bindIndex++;
 
                         $operator = match ($filterType) {
                             'equal' => '=',
@@ -2309,7 +2228,7 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
                             'greaterThanEqual' => '>=',
                             'lessThan' => '<',
                             'lessThanEqual' => '<=',
-                            default => throw new OperatorException('Unsupported filter type: ' . $filterType),
+                            default => throw new OperatorException('Unsupported filter type: '.(\is_scalar($filterType) ? (string) $filterType : 'unknown')),
                         };
 
                         // For numeric comparisons, cast to REAL; for equal/notEqual, use text comparison
@@ -2335,48 +2254,182 @@ protected function getOperatorSQL(string $column, Operator $operator, array &$bi
 
                 // Date operators
                 // no break
-            case Operator::TYPE_DATE_ADD_DAYS:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateAddDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 return "{$quotedColumn} = datetime({$quotedColumn}, :$bindKey || ' days')";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $values = $operator->getValues();
-                $bindKey = $this->registerOperatorBind($binds, $values[0] ?? 0);
+            case OperatorType::DateSubDays:
+                $bindKey = "op_{$bindIndex}";
+                $bindIndex++;
 
                 return "{$quotedColumn} = datetime({$quotedColumn}, '-' || abs(:$bindKey) || ' days')";
 
-            case Operator::TYPE_DATE_SET_NOW:
+            case OperatorType::DateSetNow:
                 return "{$quotedColumn} = datetime('now')";
 
             default:
-                // Fall back to parent implementation for other operators
-                return parent::getOperatorSQL($column, $operator, $binds);
+                return null;
         }
     }
 
     /**
-     * Override getUpsertStatement to use SQLite's ON CONFLICT syntax instead of MariaDB's ON DUPLICATE KEY UPDATE
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return 'CASE WHEN '.Storage::TENANT.' = excluded.'.Storage::TENANT." THEN excluded.{$quoted} ELSE {$quoted} END";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return "{$quoted} + excluded.{$quoted}";
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
+
+        return 'CASE WHEN '.Storage::TENANT.' = excluded.'.Storage::TENANT." THEN {$quoted} + excluded.{$quoted} ELSE {$quoted} END";
+    }
+
+    /**
+     * Override executeUpsertBatch because SQLite uses ON CONFLICT syntax which
+     * is not supported by the MySQL query builder that SQLite inherits.
      *
-     * @param string $tableName
-     * @param string $columns
-     * @param array<string> $batchKeys
-     * @param array<string> $attributes
-     * @param array<mixed> $bindValues
-     * @param string $attribute
-     * @param array<string, Operator> $operators
-     * @return mixed
-     */
-    public function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = [],
-    ): mixed {
+     * @param  string  $name  The filtered collection name
+     * @param  array<Change>  $changes  The changes to upsert
+     * @param  array<string>  $spatialAttributes  Spatial column names
+     * @param  string  $attribute  Increment attribute name (empty if none)
+     * @param  array<string, Operator>  $operators  Operator map keyed by attribute name
+     * @param  array<string, mixed>  $attributeDefaults  Attribute default values
+     * @param  bool  $hasOperators  Whether this batch contains operator expressions
+     *
+     * @throws DatabaseException
+     */
+    protected function executeUpsertBatch(
+        string $name,
+        array $changes,
+        array $spatialAttributes,
+        string $attribute,
+        array $operators,
+        array $attributeDefaults,
+        bool $hasOperators
+    ): void {
+        $bindIndex = 0;
+        $batchKeys = [];
+        $bindValues = [];
+        $allColumnNames = [];
+        $documentsData = [];
+
+        foreach ($changes as $change) {
+            $document = $change->getNew();
+
+            if ($hasOperators) {
+                $extracted = Operator::extractOperators($document->getAttributes());
+                $currentRegularAttributes = $extracted['updates'];
+                $extractedOperators = $extracted['operators'];
+
+                if ($change->getOld()->isEmpty() && ! empty($extractedOperators)) {
+                    foreach ($extractedOperators as $operatorKey => $operator) {
+                        $default = $attributeDefaults[$operatorKey] ?? null;
+                        $currentRegularAttributes[$operatorKey] = $this->applyOperatorToValue($operator, $default);
+                    }
+                }
+
+                $currentRegularAttributes[Storage::UID] = $document->getId();
+                $currentRegularAttributes[Storage::CREATED_AT] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
+                $currentRegularAttributes[Storage::UPDATED_AT] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
+            } else {
+                $currentRegularAttributes = $document->getAttributes();
+                $currentRegularAttributes[Storage::UID] = $document->getId();
+                $currentRegularAttributes[Storage::CREATED_AT] = $document->getCreatedAt() ? DatabaseDateTime::setTimezone($document->getCreatedAt()) : null;
+                $currentRegularAttributes[Storage::UPDATED_AT] = $document->getUpdatedAt() ? DatabaseDateTime::setTimezone($document->getUpdatedAt()) : null;
+            }
+
+            $currentRegularAttributes[Storage::PERMISSIONS] = \json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $currentRegularAttributes[Storage::VERSION] = $version;
+            }
+
+            if (! empty($document->getSequence())) {
+                $currentRegularAttributes[Storage::SEQUENCE] = $document->getSequence();
+            }
+
+            if ($this->sharedTables) {
+                $currentRegularAttributes[Storage::TENANT] = $document->getTenant();
+            }
+
+            foreach (\array_keys($currentRegularAttributes) as $colName) {
+                $allColumnNames[$colName] = true;
+            }
+
+            $documentsData[] = ['regularAttributes' => $currentRegularAttributes];
+        }
+
+        foreach (\array_keys($operators) as $colName) {
+            $allColumnNames[$colName] = true;
+        }
+
+        $allColumnNames = \array_keys($allColumnNames);
+        \sort($allColumnNames);
+
+        $columnsArray = [];
+        foreach ($allColumnNames as $attr) {
+            $columnsArray[] = "{$this->quote($this->filter($attr))}";
+        }
+        $columns = '('.\implode(', ', $columnsArray).')';
+
+        foreach ($documentsData as $docData) {
+            $currentRegularAttributes = $docData['regularAttributes'];
+            $bindKeys = [];
+
+            foreach ($allColumnNames as $attributeKey) {
+                $attrValue = $currentRegularAttributes[$attributeKey] ?? null;
+
+                if (\is_array($attrValue)) {
+                    $attrValue = \json_encode($attrValue);
+                }
+
+                if (in_array($attributeKey, $spatialAttributes) && $attrValue !== null) {
+                    $bindKey = 'key_'.$bindIndex;
+                    $bindKeys[] = $this->getSpatialGeomFromText(':'.$bindKey);
+                } else {
+                    if ($this->supports(Capability::IntegerBooleans)) {
+                        $attrValue = (\is_bool($attrValue)) ? (int) $attrValue : $attrValue;
+                    }
+                    $bindKey = 'key_'.$bindIndex;
+                    $bindKeys[] = ':'.$bindKey;
+                }
+                $bindValues[$bindKey] = $attrValue;
+                $bindIndex++;
+            }
+
+            $batchKeys[] = '('.\implode(', ', $bindKeys).')';
+        }
+
+        $regularAttributes = [];
+        foreach ($allColumnNames as $colName) {
+            $regularAttributes[$colName] = null;
+        }
+        foreach ($documentsData[0]['regularAttributes'] as $key => $value) {
+            $regularAttributes[$key] = $value;
+        }
+
+        // Build ON CONFLICT clause manually for SQLite
         $getUpdateClause = function (string $attribute, bool $increment = false): string {
             $attribute = $this->quote($this->filter($attribute));
             if ($increment) {
@@ -2386,37 +2439,32 @@ public function getUpsertStatement(
             }
 
             if ($this->sharedTables) {
-                return "{$attribute} = CASE WHEN _tenant = excluded._tenant THEN {$new} ELSE {$attribute} END";
+                return "{$attribute} = CASE WHEN ".Storage::TENANT.' = excluded.'.Storage::TENANT." THEN {$new} ELSE {$attribute} END";
             }
 
             return "{$attribute} = {$new}";
         };
 
         $updateColumns = [];
-        $operatorBinds = [];
+        $bindIndex = 0;
 
-        if (!empty($attribute)) {
-            // Increment specific column by its new value in place
+        if (! empty($attribute)) {
             $updateColumns = [
                 $getUpdateClause($attribute, increment: true),
-                $getUpdateClause('_updatedAt'),
+                $getUpdateClause(Storage::UPDATED_AT),
             ];
         } else {
-            // Update all columns, handling operators separately
-            foreach (\array_keys($attributes) as $attr) {
-                /**
-                 * @var string $attr
-                 */
+            foreach (\array_keys($regularAttributes) as $attr) {
+                /** @var string $attr */
                 $filteredAttr = $this->filter($attr);
 
-                // Check if this attribute has an operator
                 if (isset($operators[$attr])) {
-                    $operatorSQL = $this->getOperatorSQL($filteredAttr, $operators[$attr], $operatorBinds);
+                    $operatorSQL = $this->getOperatorSQL($filteredAttr, $operators[$attr], $bindIndex);
                     if ($operatorSQL !== null) {
                         $updateColumns[] = $operatorSQL;
                     }
                 } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
+                    if (! in_array($attr, [Storage::UID, Storage::SEQUENCE, Storage::CREATED_AT, Storage::TENANT])) {
                         $updateColumns[] = $getUpdateClause($filteredAttr);
                     }
                 }
@@ -2427,31 +2475,31 @@ public function getUpsertStatement(
         // under shared tables, so the actual UNIQUE on the documents
         // table is (_tenant, _uid). SQLite's ON CONFLICT clause needs
         // the same column order to match a UNIQUE constraint.
-        $conflictKeys = $this->sharedTables ? '(_tenant, _uid)' : '(_uid)';
+        $conflictKeys = $this->sharedTables
+            ? '('.Storage::TENANT.', '.Storage::UID.')'
+            : '('.Storage::UID.')';
 
-        $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} {$columns}
-            VALUES " . \implode(', ', $batchKeys) . "
+        $stmt = $this->prepare(
+            "INSERT INTO {$this->getSQLTable($name)} {$columns}
+            VALUES ".\implode(', ', $batchKeys)."
             ON CONFLICT {$conflictKeys} DO UPDATE
-                SET " . \implode(', ', $updateColumns)
+                SET ".\implode(', ', $updateColumns),
+            event: Event::DocumentsUpsert
         );
 
-        // Bind regular attribute values
         foreach ($bindValues as $key => $binding) {
             $stmt->bindValue($key, $binding, $this->getPDOType($binding));
         }
 
-        foreach ($operatorBinds as $bindKey => $bindValue) {
-            $stmt->bindValue($bindKey, $bindValue, $this->getPDOType($bindValue));
+        $opIndexForBinding = 0;
+        foreach (array_keys($regularAttributes) as $attr) {
+            if (isset($operators[$attr])) {
+                $this->bindOperatorParams($stmt, $operators[$attr], $opIndexForBinding);
+            }
         }
 
-        return $stmt;
-    }
-
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
+        $this->execute($stmt);
+        $stmt->closeCursor();
     }
 
     public function getSupportNonUtfCharacters(): bool
@@ -2459,34 +2507,6 @@ public function getSupportNonUtfCharacters(): bool
         return false;
     }
 
-    /**
-     * Is PCRE regex supported?
-     * SQLite does not have native REGEXP support - it requires compile-time option or user-defined function
-     *
-     * @return bool
-     */
-    public function getSupportForPCRERegex(): bool
-    {
-        return $this->pcreRegistered;
-    }
-
-    /**
-     * Is POSIX regex supported?
-     * SQLite does not have native REGEXP support - it requires compile-time option or user-defined function
-     *
-     * @return bool
-     */
-    public function getSupportForPOSIXRegex(): bool
-    {
-        // The PHP-implemented REGEXP UDF runs preg_match (PCRE), not POSIX.
-        return false;
-    }
-
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
-    }
-
     protected function getInsertKeyword(): string
     {
         return $this->skipDuplicates ? 'INSERT OR IGNORE INTO' : 'INSERT INTO';
@@ -2497,7 +2517,7 @@ protected function getInsertKeyword(): string
      * shared SQL implementation that joins many ADD COLUMN clauses with
      * commas doesn't parse here. Loop over createAttribute instead.
      *
-     * @param array<array<string, mixed>> $attributes
+     * @param array<Attribute> $attributes
      */
     public function createAttributes(string $collection, array $attributes): bool
     {
@@ -2508,15 +2528,7 @@ public function createAttributes(string $collection, array $attributes): bool
         $this->startTransaction();
         try {
             foreach ($attributes as $attribute) {
-                $this->createAttribute(
-                    $collection,
-                    $attribute['$id'],
-                    $attribute['type'],
-                    $attribute['size'] ?? 0,
-                    $attribute['signed'] ?? true,
-                    $attribute['array'] ?? false,
-                    $attribute['required'] ?? false,
-                );
+                $this->createAttributeWithEvent($collection, $attribute, Event::AttributesCreate);
             }
             $this->commitTransaction();
         } catch (\Throwable $e) {
@@ -2531,194 +2543,176 @@ public function createAttributes(string $collection, array $attributes): bool
     }
 
     /**
-     * MariaDB::createRelationship concatenates multiple ALTER TABLE
-     * statements with `;` and runs them through a single prepare/execute,
-     * which only works because MySQL accepts multi-statement queries.
-     * SQLite's PDO driver runs the first statement and silently drops the
-     * rest, so re-implement the dispatch with one statement per call.
+     * SQL::createRelationship concatenates multiple ALTER TABLE statements
+     * with `;` and runs them through a single prepare/execute, which only
+     * works because MySQL accepts multi-statement queries. SQLite's PDO
+     * driver runs the first statement and silently drops the rest, so
+     * re-implement the dispatch with one statement per call.
      */
-    public function createRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay = false,
-        string $id = '',
-        string $twoWayKey = ''
-    ): bool {
-        $name = $this->filter($collection);
-        $relatedName = $this->filter($relatedCollection);
+    public function createRelationship(Relationship $relationship): bool
+    {
+        $name = $this->filter($relationship->collection);
+        $relatedName = $this->filter($relationship->relatedCollection);
         $table = $this->getSQLTable($name);
         $relatedTable = $this->getSQLTable($relatedName);
-        $id = $this->filter($id);
-        $twoWayKey = $this->filter($twoWayKey);
-        $sqlType = $this->getSQLType(Database::VAR_RELATIONSHIP, 0, false, false, false);
+        $id = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $sqlType = $this->getSQLType(ColumnType::Relationship, 0, false, false, false);
+        $twoWay = $relationship->twoWay;
 
-        $statements = match ($type) {
-            Database::RELATION_ONE_TO_ONE => $twoWay
+        $statements = match ($relationship->type) {
+            RelationType::OneToOne => $twoWay
                 ? [
                     "ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL",
                     "ALTER TABLE {$relatedTable} ADD COLUMN `{$twoWayKey}` {$sqlType} DEFAULT NULL",
                 ]
                 : ["ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL"],
-            Database::RELATION_ONE_TO_MANY => ["ALTER TABLE {$relatedTable} ADD COLUMN `{$twoWayKey}` {$sqlType} DEFAULT NULL"],
-            Database::RELATION_MANY_TO_ONE => ["ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL"],
-            Database::RELATION_MANY_TO_MANY => [],
-            default => throw new DatabaseException('Invalid relationship type'),
+            RelationType::OneToMany => ["ALTER TABLE {$relatedTable} ADD COLUMN `{$twoWayKey}` {$sqlType} DEFAULT NULL"],
+            RelationType::ManyToOne => ["ALTER TABLE {$table} ADD COLUMN `{$id}` {$sqlType} DEFAULT NULL"],
+            RelationType::ManyToMany => [],
         };
 
         foreach ($statements as $stmt) {
-            $stmt = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $stmt);
-            $this->getPDO()->prepare($stmt)->execute();
+            $this->execute($this->prepare($stmt, event: Event::AttributeCreate));
         }
 
         return true;
     }
 
     public function updateRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side,
+        Relationship $relationship,
         ?string $newKey = null,
         ?string $newTwoWayKey = null,
     ): bool {
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
         $name = $this->filter($collection);
         $relatedName = $this->filter($relatedCollection);
         $table = $this->getSQLTable($name);
         $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
 
-        if (!\is_null($newKey)) {
+        if ($newKey !== null) {
             $newKey = $this->filter($newKey);
         }
-        if (!\is_null($newTwoWayKey)) {
+        if ($newTwoWayKey !== null) {
             $newTwoWayKey = $this->filter($newTwoWayKey);
         }
 
         $statements = [];
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if (!\is_null($newKey) && $key !== $newKey) {
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($newKey !== null && $key !== $newKey) {
                     $statements[] = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`";
                 }
-                if ($twoWay && !\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+                if ($twoWay && $newTwoWayKey !== null && $twoWayKey !== $newTwoWayKey) {
                     $statements[] = "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`";
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    if (!\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    if ($newTwoWayKey !== null && $twoWayKey !== $newTwoWayKey) {
                         $statements[] = "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`";
                     }
                 } else {
-                    if (!\is_null($newKey) && $key !== $newKey) {
+                    if ($newKey !== null && $key !== $newKey) {
                         $statements[] = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`";
                     }
                 }
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    if (!\is_null($newTwoWayKey) && $twoWayKey !== $newTwoWayKey) {
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
+                    if ($newTwoWayKey !== null && $twoWayKey !== $newTwoWayKey) {
                         $statements[] = "ALTER TABLE {$relatedTable} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`";
                     }
                 } else {
-                    if (!\is_null($newKey) && $key !== $newKey) {
+                    if ($newKey !== null && $key !== $newKey) {
                         $statements[] = "ALTER TABLE {$table} RENAME COLUMN `{$key}` TO `{$newKey}`";
                     }
                 }
                 break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collectionDoc = $this->getDocument($metadataCollection, $collection);
+                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
 
-                $junction = $this->getSQLTable('_' . $collection->getSequence() . '_' . $relatedCollection->getSequence());
+                $junction = $this->getSQLTable('_' . $collectionDoc->getSequence() . '_' . $relatedCollectionDoc->getSequence());
 
-                if (!\is_null($newKey)) {
+                if ($newKey !== null) {
                     $statements[] = "ALTER TABLE {$junction} RENAME COLUMN `{$key}` TO `{$newKey}`";
                 }
-                if ($twoWay && !\is_null($newTwoWayKey)) {
+                if ($twoWay && $newTwoWayKey !== null) {
                     $statements[] = "ALTER TABLE {$junction} RENAME COLUMN `{$twoWayKey}` TO `{$newTwoWayKey}`";
                 }
                 break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
         }
 
         foreach ($statements as $stmt) {
-            $stmt = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $stmt);
-            $this->getPDO()->prepare($stmt)->execute();
+            $this->execute($this->prepare($stmt, event: Event::AttributeUpdate));
         }
 
         return true;
     }
 
-    public function deleteRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side
-    ): bool {
+    public function deleteRelationship(Relationship $relationship): bool
+    {
+        $collection = $relationship->collection;
+        $relatedCollection = $relationship->relatedCollection;
         $name = $this->filter($collection);
         $relatedName = $this->filter($relatedCollection);
         $table = $this->getSQLTable($name);
         $relatedTable = $this->getSQLTable($relatedName);
-        $key = $this->filter($key);
-        $twoWayKey = $this->filter($twoWayKey);
+        $key = $this->filter($relationship->key);
+        $twoWayKey = $this->filter($relationship->twoWayKey);
+        $twoWay = $relationship->twoWay;
+        $side = $relationship->side;
 
         $statements = [];
 
-        switch ($type) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
+        switch ($relationship->type) {
+            case RelationType::OneToOne:
+                if ($side === RelationSide::Parent) {
                     $statements[] = "ALTER TABLE {$table} DROP COLUMN `{$key}`";
                     if ($twoWay) {
                         $statements[] = "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`";
                     }
-                } elseif ($side === Database::RELATION_SIDE_CHILD) {
+                } elseif ($side === RelationSide::Child) {
                     $statements[] = "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`";
                     if ($twoWay) {
                         $statements[] = "ALTER TABLE {$table} DROP COLUMN `{$key}`";
                     }
                 }
                 break;
-            case Database::RELATION_ONE_TO_MANY:
-                $statements[] = $side === Database::RELATION_SIDE_PARENT
+            case RelationType::OneToMany:
+                $statements[] = $side === RelationSide::Parent
                     ? "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`"
                     : "ALTER TABLE {$table} DROP COLUMN `{$key}`";
                 break;
-            case Database::RELATION_MANY_TO_ONE:
-                $statements[] = $side === Database::RELATION_SIDE_PARENT
+            case RelationType::ManyToOne:
+                $statements[] = $side === RelationSide::Parent
                     ? "ALTER TABLE {$table} DROP COLUMN `{$key}`"
                     : "ALTER TABLE {$relatedTable} DROP COLUMN `{$twoWayKey}`";
                 break;
-            case Database::RELATION_MANY_TO_MANY:
-                $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collection = $this->getDocument($metadataCollection, $collection);
-                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
+            case RelationType::ManyToMany:
+                $metadataCollection = new Document([Document::ID => Database::METADATA]);
+                $collectionDoc = $this->getDocument($metadataCollection, $collection);
+                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
 
-                $junctionBase = $side === Database::RELATION_SIDE_PARENT
-                    ? '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence()
-                    : '_' . $relatedCollection->getSequence() . '_' . $collection->getSequence();
+                $junctionBase = $side === RelationSide::Parent
+                    ? '_' . $collectionDoc->getSequence() . '_' . $relatedCollectionDoc->getSequence()
+                    : '_' . $relatedCollectionDoc->getSequence() . '_' . $collectionDoc->getSequence();
 
                 $statements[] = "DROP TABLE {$this->getSQLTable($junctionBase)}";
-                $statements[] = "DROP TABLE {$this->getSQLTable($junctionBase . '_perms')}";
+                $statements[] = "DROP TABLE {$this->getSQLTable(Storage::permissionsTable($junctionBase))}";
                 break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
         }
 
         foreach ($statements as $stmt) {
-            $stmt = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $stmt);
-            $this->getPDO()->prepare($stmt)->execute();
+            $this->execute($this->prepare($stmt, event: Event::AttributeDelete));
         }
 
         return true;
@@ -2737,18 +2731,22 @@ public function getSchemaAttributes(string $collection): array
     {
         $table = "{$this->getNamespace()}_{$this->filter($collection)}";
 
-        $stmt = $this->getPDO()->prepare("PRAGMA table_info(`{$table}`)");
-        $stmt->execute();
+        $stmt = $this->prepare("PRAGMA table_info(`{$table}`)", event: Event::CollectionRead);
+        $this->execute($stmt);
         $rows = $stmt->fetchAll();
         $stmt->closeCursor();
 
         $results = [];
         foreach ($rows as $row) {
-            $rawType = (string) ($row['type'] ?? '');
+            if (! \is_array($row)) {
+                continue;
+            }
+            $rawType = \is_scalar($row['type'] ?? null) ? (string) $row['type'] : '';
             $parsed = $this->parseSqliteColumnType($rawType);
+            $name = \is_scalar($row['name'] ?? null) ? (string) $row['name'] : '';
 
             $results[] = new Document([
-                '$id' => $row['name'],
+                Document::ID => $name,
                 'columnDefault' => $row['dflt_value'] ?? null,
                 'isNullable' => empty($row['notnull']) ? 'YES' : 'NO',
                 'dataType' => $parsed['dataType'],
@@ -2757,7 +2755,7 @@ public function getSchemaAttributes(string $collection): array
                 'numericScale' => $parsed['numericScale'],
                 'datetimePrecision' => $parsed['datetimePrecision'],
                 'columnType' => \strtolower($rawType),
-                'columnKey' => !empty($row['pk']) ? 'PRI' : '',
+                'columnKey' => ! empty($row['pk']) ? 'PRI' : '',
                 'extra' => '',
             ]);
         }
@@ -2778,32 +2776,45 @@ public function getSchemaIndexes(string $collection): array
     {
         $table = "{$this->getNamespace()}_{$this->filter($collection)}";
 
-        $stmt = $this->getPDO()->prepare("PRAGMA index_list(`{$table}`)");
-        $stmt->execute();
+        $stmt = $this->prepare("PRAGMA index_list(`{$table}`)", event: Event::CollectionRead);
+        $this->execute($stmt);
         $indexes = $stmt->fetchAll();
         $stmt->closeCursor();
 
         $results = [];
         foreach ($indexes as $index) {
-            $name = $index['name'];
-            $unique = !empty($index['unique']);
+            if (! \is_array($index)) {
+                continue;
+            }
+            $name = \is_scalar($index['name'] ?? null) ? (string) $index['name'] : '';
+            $unique = ! empty($index['unique']);
 
-            $colStmt = $this->getPDO()->prepare("PRAGMA index_info(`{$name}`)");
-            $colStmt->execute();
+            $colStmt = $this->prepare("PRAGMA index_info(`{$name}`)", event: Event::CollectionRead);
+            $this->execute($colStmt);
             $cols = $colStmt->fetchAll();
             $colStmt->closeCursor();
 
-            \usort($cols, fn ($a, $b) => ((int) $a['seqno']) <=> ((int) $b['seqno']));
+            \usort(
+                $cols,
+                fn (mixed $a, mixed $b) => (
+                    \is_array($a) && \is_scalar($a['seqno'] ?? null) ? (int) $a['seqno'] : 0
+                ) <=> (
+                    \is_array($b) && \is_scalar($b['seqno'] ?? null) ? (int) $b['seqno'] : 0
+                )
+            );
 
             $columns = [];
             $lengths = [];
             foreach ($cols as $col) {
-                $columns[] = $col['name'];
+                if (! \is_array($col)) {
+                    continue;
+                }
+                $columns[] = \is_scalar($col['name'] ?? null) ? (string) $col['name'] : '';
                 $lengths[] = null;
             }
 
             $results[] = new Document([
-                '$id' => $name,
+                Document::ID => $name,
                 'indexName' => $name,
                 'indexType' => 'BTREE',
                 'nonUnique' => $unique ? 0 : 1,
@@ -2844,30 +2855,34 @@ protected function getFulltextSchemaIndexes(string $collection): array
 
         $hashToId = [];
         try {
-            $metadataCollection = new Document(['$id' => Database::METADATA]);
+            $metadataCollection = new Document([Document::ID => Database::METADATA]);
             $collectionDoc = $this->getDocument($metadataCollection, $collection);
-            if (!$collectionDoc->isEmpty()) {
-                foreach ($collectionDoc->getAttribute('indexes', []) as $index) {
-                    $indexId = $index instanceof Document
-                        ? $index->getId()
-                        : (\is_array($index) ? ($index['$id'] ?? null) : null);
-                    $type = $index instanceof Document
-                        ? $index->getAttribute('type')
-                        : (\is_array($index) ? ($index['type'] ?? null) : null);
-
-                    if ($indexId === null || $type !== Database::INDEX_FULLTEXT) {
-                        continue;
-                    }
+            if (! $collectionDoc->isEmpty()) {
+                $indexes = $collectionDoc->getAttribute('indexes', []);
+                if (\is_array($indexes)) {
+                    foreach ($indexes as $index) {
+                        if ($index instanceof Document) {
+                            $indexId = $index->getId();
+                            $type = $index->getAttribute('type');
+                            $attributes = $index->getAttribute('attributes', []);
+                        } elseif (\is_array($index)) {
+                            $indexId = $index[Document::ID] ?? null;
+                            $type = $index['type'] ?? null;
+                            $attributes = $index['attributes'] ?? [];
+                        } else {
+                            continue;
+                        }
 
-                    $attributes = $index instanceof Document
-                        ? $index->getAttribute('attributes', [])
-                        : ($index['attributes'] ?? []);
+                        if (! \is_scalar($indexId) || $type !== IndexType::Fulltext->value) {
+                            continue;
+                        }
 
-                    $internal = \array_map(
-                        fn (string $a) => $this->getInternalKeyForAttribute($a),
-                        (array) $attributes
-                    );
-                    $hashToId[$this->getFulltextTableName($collection, $internal)] = $this->filter((string) $indexId);
+                        $internal = \array_map(
+                            fn (mixed $a): string => \is_string($a) ? $this->getInternalKeyForAttribute($a) : '',
+                            \is_array($attributes) ? $attributes : []
+                        );
+                        $hashToId[$this->getFulltextTableName($collection, $internal)] = $this->filter((string) $indexId);
+                    }
                 }
             }
         } catch (\Throwable) {
@@ -2875,14 +2890,17 @@ protected function getFulltextSchemaIndexes(string $collection): array
 
         $entries = [];
         foreach ($tables as $ftsTable) {
-            $info = $this->getPDO()->prepare("PRAGMA table_info(`{$ftsTable}`)");
+            $info = $this->prepare("PRAGMA table_info(`{$ftsTable}`)");
             $info->execute();
             $cols = $info->fetchAll(PDO::FETCH_ASSOC);
             $info->closeCursor();
 
             $columns = [];
             foreach ($cols as $col) {
-                $name = (string) ($col['name'] ?? '');
+                if (! \is_array($col)) {
+                    continue;
+                }
+                $name = \is_scalar($col['name'] ?? null) ? (string) $col['name'] : '';
                 if ($name === '') {
                     continue;
                 }
@@ -2892,7 +2910,7 @@ protected function getFulltextSchemaIndexes(string $collection): array
             $id = $hashToId[$ftsTable] ?? $ftsTable;
 
             $entries[] = [
-                '$id' => $id,
+                Document::ID => $id,
                 'indexName' => $id,
                 'indexType' => 'FULLTEXT',
                 'nonUnique' => 1,
@@ -2931,7 +2949,7 @@ private function parseSqliteColumnType(string $declaration): array
         if (\preg_match('/^([A-Za-z]+)\s*\((\d+)(?:\s*,\s*(\d+))?\s*\)/', $declaration, $matches) === 1) {
             $base = $matches[1];
             $argument = (int) $matches[2];
-            if (isset($matches[3]) && $matches[3] !== '') {
+            if (isset($matches[3])) {
                 $secondArgument = (int) $matches[3];
             }
         }
@@ -3063,22 +3081,22 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
         $method = $query->getMethod();
 
         $likeMethods = [
-            Query::TYPE_STARTS_WITH,
-            Query::TYPE_NOT_STARTS_WITH,
-            Query::TYPE_ENDS_WITH,
-            Query::TYPE_NOT_ENDS_WITH,
-            Query::TYPE_CONTAINS,
-            Query::TYPE_CONTAINS_ANY,
-            Query::TYPE_NOT_CONTAINS,
+            Method::StartsWith,
+            Method::NotStartsWith,
+            Method::EndsWith,
+            Method::NotEndsWith,
+            Method::Contains,
+            Method::ContainsAny,
+            Method::NotContains,
         ];
 
-        if (\in_array($method, $likeMethods, true)) {
+        if (\in_array($method, $likeMethods, true) && ! $query->isSpatialAttribute()) {
             // Array CONTAINS via json_each — exact element match without
             // LIKE substring false positives (`%2%` matching `[12, 200]`).
             $arrayContainsMethods = [
-                Query::TYPE_CONTAINS,
-                Query::TYPE_CONTAINS_ANY,
-                Query::TYPE_NOT_CONTAINS,
+                Method::Contains,
+                Method::ContainsAny,
+                Method::NotContains,
             ];
             if ($query->onArray() && \in_array($method, $arrayContainsMethods, true)) {
                 return $this->buildArrayContainsCondition($query, $binds);
@@ -3087,7 +3105,7 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
             return $this->getLikeCondition($query, $binds);
         }
 
-        if ($method !== Query::TYPE_SEARCH && $method !== Query::TYPE_NOT_SEARCH) {
+        if ($method !== Method::Search && $method !== Method::NotSearch) {
             return parent::getSQLCondition($query, $binds, $forCollection);
         }
 
@@ -3096,12 +3114,13 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
         $alias = $this->quote(Query::DEFAULT_ALIAS);
         $placeholder = ID::unique();
 
-        $rawValue = (string) $query->getValue();
+        $queryValue = $query->getValue();
+        $rawValue = \is_scalar($queryValue) ? (string) $queryValue : '';
         $ftsValue = $this->getFTS5Value($rawValue);
 
         if ($ftsValue === '') {
             // Empty term — FTS5 syntax-errors on the empty string.
-            return $method === Query::TYPE_SEARCH ? '1 = 0' : '1 = 1';
+            return $method === Method::Search ? '1 = 0' : '1 = 1';
         }
 
         $ftsTable = $forCollection === null
@@ -3116,9 +3135,9 @@ protected function getSQLCondition(Query $query, array &$binds, ?string $forColl
 
         $binds[":{$placeholder}_0"] = $ftsValue;
 
-        $subquery = "{$alias}.`_id` IN (SELECT rowid FROM `{$ftsTable}` WHERE `{$ftsTable}` MATCH :{$placeholder}_0)";
+        $subquery = "{$alias}.{$this->quote(Storage::SEQUENCE)} IN (SELECT rowid FROM `{$ftsTable}` WHERE `{$ftsTable}` MATCH :{$placeholder}_0)";
 
-        return $method === Query::TYPE_SEARCH ? $subquery : "NOT ({$subquery})";
+        return $method === Method::Search ? $subquery : "NOT ({$subquery})";
     }
 
     /**
@@ -3131,13 +3150,13 @@ private function buildSearchLikeFallback(
         string $value,
         string $alias,
         string $placeholder,
-        string $method,
+        Method $method,
         array &$binds,
     ): string {
         $binds[":{$placeholder}_0"] = '%' . $this->escapeWildcards($value) . '%';
         $sql = "{$alias}.{$this->quote($attribute)} LIKE :{$placeholder}_0 ESCAPE '\\'";
 
-        return $method === Query::TYPE_SEARCH ? $sql : "NOT ({$sql})";
+        return $method === Method::Search ? $sql : "NOT ({$sql})";
     }
 
     /**
@@ -3172,7 +3191,7 @@ private function buildArrayContainsCondition(Query $query, array &$binds): strin
             . \implode(', ', $params)
             . '))';
 
-        return $method === Query::TYPE_NOT_CONTAINS ? "NOT {$expression}" : $expression;
+        return $method === Method::NotContains ? "NOT {$expression}" : $expression;
     }
 
     /**
@@ -3182,6 +3201,13 @@ private function buildArrayContainsCondition(Query $query, array &$binds): strin
      */
     protected function findFulltextTableForAttribute(string $collection, string $attribute): ?string
     {
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false) {
+            return null;
+        }
+
+        $attribute = $this->filter($this->getInternalKeyForAttribute($attribute));
+
         if (!\array_key_exists($collection, $this->ftsTableCache)) {
             $this->ftsTableCache[$collection] = $this->buildFulltextAttributeMap($collection);
         }
@@ -3196,11 +3222,14 @@ private function buildFulltextAttributeMap(string $collection): array
     {
         $map = [];
         foreach ($this->findFulltextTables($collection) as $table) {
-            $info = $this->getPDO()->prepare("PRAGMA table_info(`{$table}`)");
+            $info = $this->prepare("PRAGMA table_info(`{$table}`)");
             $info->execute();
             $cols = $info->fetchAll(PDO::FETCH_ASSOC);
             $info->closeCursor();
             foreach ($cols as $col) {
+                if (! \is_array($col)) {
+                    continue;
+                }
                 $name = $col['name'] ?? null;
                 if (\is_string($name) && $name !== '') {
                     $map[$name] = $table;
@@ -3228,17 +3257,18 @@ protected function getLikeCondition(Query $query, array &$binds): string
         $placeholder = ID::unique();
 
         $isNotQuery = \in_array($method, [
-            Query::TYPE_NOT_STARTS_WITH,
-            Query::TYPE_NOT_ENDS_WITH,
-            Query::TYPE_NOT_CONTAINS,
+            Method::NotStartsWith,
+            Method::NotEndsWith,
+            Method::NotContains,
         ], true);
 
         $conditions = [];
         foreach ($query->getValues() as $key => $value) {
+            $strValue = \is_string($value) ? $value : '';
             $bound = match ($method) {
-                Query::TYPE_STARTS_WITH, Query::TYPE_NOT_STARTS_WITH => $this->escapeWildcards($value) . '%',
-                Query::TYPE_ENDS_WITH, Query::TYPE_NOT_ENDS_WITH => '%' . $this->escapeWildcards($value),
-                Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_NOT_CONTAINS => '%' . $this->escapeWildcards($value) . '%',
+                Method::StartsWith, Method::NotStartsWith => $this->escapeWildcards($strValue) . '%',
+                Method::EndsWith, Method::NotEndsWith => '%' . $this->escapeWildcards($strValue),
+                Method::Contains, Method::ContainsAny, Method::NotContains => '%' . $this->escapeWildcards($strValue) . '%',
                 default => $value,
             };
 
@@ -3285,7 +3315,7 @@ protected function getFTS5Value(string $value): string
             return $token;
         }, $tokens);
         $last = \array_pop($tokens);
-        if ($last !== null && !\str_starts_with($last, '"')) {
+        if (! \str_starts_with($last, '"')) {
             $last .= '*';
         }
         $tokens[] = $last;
diff --git a/src/Database/Attribute.php b/src/Database/Attribute.php
new file mode 100644
index 0000000000..3af7d9bb61
--- /dev/null
+++ b/src/Database/Attribute.php
@@ -0,0 +1,1893 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Represents a database collection attribute with its type, constraints, and formatting options.
+ *
+ * @property string $key
+ * @property ColumnType $type
+ * @property int $size
+ * @property bool $required
+ * @property mixed $default
+ * @property bool $signed
+ * @property bool $array
+ * @property string|null $format
+ * @property array<string, mixed> $formatOptions
+ * @property array<string> $filters
+ * @property string|null $status
+ * @property array<string, mixed>|null $options
+ */
+class Attribute extends Document
+{
+    public const string LEGACY_BIG_INTEGER = 'bigint';
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        ColumnType $type = ColumnType::String,
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        if (\in_array($type, [ColumnType::BigInteger, ColumnType::BigSerial], true)) {
+            $size = 0;
+        }
+
+        $data = [
+            self::ID => $key,
+            'key' => $key,
+            'type' => $type->value,
+            'size' => $size,
+            'required' => $required,
+            'default' => $default,
+            'signed' => $signed,
+            'array' => $array,
+            'format' => $format,
+            'formatOptions' => $formatOptions,
+            'filters' => $filters,
+        ];
+        if ($status !== null) {
+            $data['status'] = $status;
+        }
+        if ($options !== null) {
+            $data['options'] = $options;
+        }
+        parent::__construct($data);
+    }
+
+    /**
+     * @return (
+     *     $name is 'key' ? string :
+     *     $name is 'type' ? ColumnType :
+     *     $name is 'size' ? int :
+     *     $name is 'required' ? bool :
+     *     $name is 'default' ? mixed :
+     *     $name is 'signed' ? bool :
+     *     $name is 'array' ? bool :
+     *     $name is 'format' ? string|null :
+     *     $name is 'formatOptions' ? array<string, mixed> :
+     *     $name is 'filters' ? array<string> :
+     *     $name is 'status' ? string|null :
+     *     $name is 'options' ? array<string, mixed>|null :
+     *     mixed
+     * )
+     */
+    public function __get(string $name): mixed
+    {
+        switch ($name) {
+            case 'key':
+                /** @var string $key */
+                $key = $this->getAttribute('key', $this->getId());
+
+                return $key;
+            case 'type':
+                /** @var ColumnType|string $type */
+                $type = $this->getAttribute('type', ColumnType::String->value);
+
+                return self::normalizeType($type);
+            case 'size':
+                /** @var int $size */
+                $size = $this->getAttribute('size', 0);
+
+                return $size;
+            case 'required':
+                return (bool) $this->getAttribute('required', false);
+            case 'default':
+                return $this->getAttribute('default');
+            case 'signed':
+                return (bool) $this->getAttribute('signed', true);
+            case 'array':
+                return (bool) $this->getAttribute('array', false);
+            case 'format':
+                $format = $this->getAttribute('format');
+
+                return \is_string($format) ? $format : null;
+            case 'formatOptions':
+                $formatOptions = $this->getAttribute('formatOptions', []);
+                if (! \is_array($formatOptions)) {
+                    return [];
+                }
+                /** @var array<string, mixed> $formatOptions */
+
+                return $formatOptions;
+            case 'filters':
+                $filters = $this->getAttribute('filters', []);
+                if (! \is_array($filters)) {
+                    return [];
+                }
+                /** @var array<string> $filters */
+
+                return $filters;
+            case 'status':
+                $status = $this->getAttribute('status');
+
+                return \is_string($status) ? $status : null;
+            case 'options':
+                $options = $this->getAttribute('options');
+                if (! \is_array($options)) {
+                    return null;
+                }
+                /** @var array<string, mixed> $options */
+
+                return $options;
+            default:
+                return $this->getAttribute($name);
+        }
+    }
+
+    public function __set(string $name, mixed $value): void
+    {
+        match ($name) {
+            'key' => $this->setAttribute('key', $value)->setAttribute(self::ID, $value),
+            'type' => $this->setAttribute('type', $value instanceof ColumnType ? $value->value : $value),
+            'size' => $this->setAttribute('size', $value),
+            'required' => $this->setAttribute('required', $value),
+            'default' => $this->setAttribute('default', $value),
+            'signed' => $this->setAttribute('signed', $value),
+            'array' => $this->setAttribute('array', $value),
+            'format' => $this->setAttribute('format', $value),
+            'formatOptions' => $this->setAttribute('formatOptions', $value),
+            'filters' => $this->setAttribute('filters', $value),
+            'status' => $this->setAttribute('status', $value),
+            'options' => $this->setAttribute('options', $value),
+            default => $this->setAttribute($name, $value),
+        };
+    }
+
+    public function __isset(string $name): bool
+    {
+        return match ($name) {
+            'key', 'type', 'size', 'required', 'default', 'signed', 'array', 'format', 'formatOptions', 'filters', 'status', 'options' => true,
+            default => $this->offsetExists($name),
+        };
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function string(
+        string $key = '',
+        int $size = Database::LENGTH_KEY,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\StringType {
+        return new Attribute\StringType(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function varchar(
+        string $key = '',
+        int $size = Database::LENGTH_KEY,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Varchar {
+        return new Attribute\Varchar(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function text(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Text {
+        return new Attribute\Text(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function mediumText(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\MediumText {
+        return new Attribute\MediumText(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function longText(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\LongText {
+        return new Attribute\LongText(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function tinyInteger(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\TinyInteger {
+        return new Attribute\TinyInteger(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function smallInteger(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\SmallInteger {
+        return new Attribute\SmallInteger(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function integer(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Integer {
+        return new Attribute\Integer(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function bigInteger(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\BigInteger {
+        return new Attribute\BigInteger(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function float(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\FloatType {
+        return new Attribute\FloatType(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function double(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Double {
+        return new Attribute\Double(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function decimal(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Decimal {
+        return new Attribute\Decimal(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function boolean(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Boolean {
+        return new Attribute\Boolean(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function datetime(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Datetime {
+        return new Attribute\Datetime(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function timestamp(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Timestamp {
+        return new Attribute\Timestamp(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function json(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Json {
+        return new Attribute\Json(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function binary(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Binary {
+        return new Attribute\Binary(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function enum(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\EnumType {
+        return new Attribute\EnumType(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function point(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Point {
+        return new Attribute\Point(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function linestring(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Linestring {
+        return new Attribute\Linestring(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function polygon(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Polygon {
+        return new Attribute\Polygon(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function vector(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Vector {
+        return new Attribute\Vector(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function id(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Id {
+        return new Attribute\Id(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function uuid(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Uuid {
+        return new Attribute\Uuid(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function uuid7(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Uuid7 {
+        return new Attribute\Uuid7(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function object(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\ObjectType {
+        return new Attribute\ObjectType(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function relationship(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Relationship {
+        return new Attribute\Relationship(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function serial(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Serial {
+        return new Attribute\Serial(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function bigSerial(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\BigSerial {
+        return new Attribute\BigSerial(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function smallSerial(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\SmallSerial {
+        return new Attribute\SmallSerial(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function array(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\ArrayType {
+        return new Attribute\ArrayType(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public static function tuple(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ): Attribute\Tuple {
+        return new Attribute\Tuple(
+            key: $key,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    public static function normalizeType(ColumnType|string $type): ColumnType
+    {
+        if ($type instanceof ColumnType) {
+            return $type;
+        }
+
+        return ColumnType::from($type === self::LEGACY_BIG_INTEGER ? ColumnType::BigInteger->value : $type);
+    }
+
+    public static function tryNormalizeType(ColumnType|string $type): ?ColumnType
+    {
+        if ($type instanceof ColumnType) {
+            return $type;
+        }
+
+        return ColumnType::tryFrom($type === self::LEGACY_BIG_INTEGER ? ColumnType::BigInteger->value : $type);
+    }
+
+    public static function isNumericType(ColumnType|string $type): bool
+    {
+        $type = self::tryNormalizeType($type);
+
+        return \in_array($type, [
+            ColumnType::Integer,
+            ColumnType::BigInteger,
+            ColumnType::Float,
+            ColumnType::Double,
+            ColumnType::BigSerial,
+        ], true);
+    }
+
+    public static function isIntegerType(ColumnType|string $type): bool
+    {
+        $type = self::tryNormalizeType($type);
+
+        return \in_array($type, [
+            ColumnType::Integer,
+            ColumnType::BigInteger,
+            ColumnType::BigSerial,
+        ], true);
+    }
+
+    /**
+     * @return array{min: int|float|string, max: int|float|string}|null
+     */
+    public static function getNumericBounds(ColumnType|string $type, bool $signed = true): ?array
+    {
+        $type = self::tryNormalizeType($type);
+
+        return match ($type) {
+            ColumnType::Integer => [
+                'min' => $signed ? Database::MIN_INT : 0,
+                'max' => Database::MAX_INT,
+            ],
+            ColumnType::BigInteger,
+            ColumnType::BigSerial => [
+                'min' => $signed ? \PHP_INT_MIN : 0,
+                'max' => $signed ? Database::MAX_BIG_INT : BigInt::UNSIGNED_MAX,
+            ],
+            ColumnType::Float,
+            ColumnType::Double => [
+                'min' => $signed ? -Database::MAX_DOUBLE : 0,
+                'max' => Database::MAX_DOUBLE,
+            ],
+            default => null,
+        };
+    }
+
+    /**
+     * Convert this attribute to a Document representation.
+     *
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        $data = [
+            Document::ID => ID::custom($this->key),
+            'key' => $this->key,
+            'type' => $this->type->value,
+            'size' => $this->size,
+            'required' => $this->required,
+            'default' => $this->default,
+            'signed' => $this->signed,
+            'array' => $this->array,
+            'format' => $this->format,
+            'formatOptions' => $this->formatOptions,
+            'filters' => $this->filters,
+        ];
+
+        if ($this->status !== null) {
+            $data['status'] = $this->status;
+        }
+
+        if ($this->options !== null) {
+            $data['options'] = $this->options;
+        }
+
+        return new Document($data);
+    }
+
+    /**
+     * Create an Attribute instance from a Document.
+     *
+     * @param Document $document The document to convert
+     * @return self
+     */
+    public static function fromDocument(Document $document): self
+    {
+        /** @var string $key */
+        $key = $document->getAttribute('key', $document->getId());
+        /** @var ColumnType|string $type */
+        $type = $document->getAttribute('type', 'string');
+        /** @var int $size */
+        $size = $document->getAttribute('size', 0);
+        /** @var bool $required */
+        $required = $document->getAttribute('required', false);
+        /** @var bool $signed */
+        $signed = $document->getAttribute('signed', true);
+        /** @var bool $array */
+        $array = $document->getAttribute('array', false);
+        /** @var string|null $format */
+        $format = $document->getAttribute('format');
+        /** @var array<string, mixed> $formatOptions */
+        $formatOptions = $document->getAttribute('formatOptions', []);
+        /** @var array<string> $filters */
+        $filters = $document->getAttribute('filters', []);
+        /** @var string|null $status */
+        $status = $document->getAttribute('status');
+        /** @var array<string, mixed>|null $options */
+        $options = $document->getAttribute('options');
+
+        return self::make(
+            key: $key,
+            type: self::normalizeType($type),
+            size: $size,
+            required: $required,
+            default: $document->getAttribute('default'),
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * Cheap relationship-type check that avoids materializing a typed Attribute.
+     * Use in hot read paths where only the type matters.
+     *
+     * Mirrors the normalization in {@see self::fromDocument()} — accepts both
+     * the (always-stored) string form and the defensive ColumnType-enum form.
+     */
+    public static function isRelationship(self|Document $attribute): bool
+    {
+        if ($attribute instanceof self) {
+            return $attribute->type === ColumnType::Relationship;
+        }
+
+        $type = $attribute->getAttribute('type');
+
+        if ($type instanceof ColumnType) {
+            return $type === ColumnType::Relationship;
+        }
+
+        return $type === ColumnType::Relationship->value;
+    }
+
+    /**
+     * Create from an associative array (used by batch operations).
+     *
+     * @param  array<string, mixed>  $data
+     * @return self
+     */
+    public static function fromArray(array $data): self
+    {
+        /** @var ColumnType|string $type */
+        $type = $data['type'] ?? 'string';
+
+        /** @var string $key */
+        $key = $data[Document::ID] ?? $data['key'] ?? '';
+        /** @var int $size */
+        $size = $data['size'] ?? 0;
+        /** @var bool $required */
+        $required = $data['required'] ?? false;
+        /** @var bool $signed */
+        $signed = $data['signed'] ?? true;
+        /** @var bool $array */
+        $array = $data['array'] ?? false;
+        /** @var string|null $format */
+        $format = $data['format'] ?? null;
+        /** @var array<string, mixed> $formatOptions */
+        $formatOptions = $data['formatOptions'] ?? [];
+        /** @var array<string> $filters */
+        $filters = $data['filters'] ?? [];
+        /** @var string|null $status */
+        $status = $data['status'] ?? null;
+        /** @var array<string, mixed>|null $options */
+        $options = $data['options'] ?? null;
+
+        return self::make(
+            key: $key,
+            type: self::normalizeType($type),
+            size: $size,
+            required: $required,
+            default: $data['default'] ?? null,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    private static function make(
+        string $key,
+        ColumnType $type,
+        int $size,
+        bool $required,
+        mixed $default,
+        bool $signed,
+        bool $array,
+        ?string $format,
+        array $formatOptions,
+        array $filters,
+        ?string $status = null,
+        ?array $options = null,
+    ): self {
+        return match ($type) {
+            ColumnType::String => new Attribute\StringType(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Varchar => new Attribute\Varchar(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Text => new Attribute\Text(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::MediumText => new Attribute\MediumText(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::LongText => new Attribute\LongText(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::TinyInteger => new Attribute\TinyInteger(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::SmallInteger => new Attribute\SmallInteger(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Integer => new Attribute\Integer(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::BigInteger => new Attribute\BigInteger(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Float => new Attribute\FloatType(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Double => new Attribute\Double(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Decimal => new Attribute\Decimal(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Boolean => new Attribute\Boolean(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Datetime => new Attribute\Datetime(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Timestamp => new Attribute\Timestamp(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Json => new Attribute\Json(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Binary => new Attribute\Binary(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Enum => new Attribute\EnumType(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Point => new Attribute\Point(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Linestring => new Attribute\Linestring(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Polygon => new Attribute\Polygon(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Vector => new Attribute\Vector(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Id => new Attribute\Id(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Uuid => new Attribute\Uuid(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Uuid7 => new Attribute\Uuid7(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Object => new Attribute\ObjectType(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Relationship => new Attribute\Relationship(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Serial => new Attribute\Serial(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::BigSerial => new Attribute\BigSerial(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::SmallSerial => new Attribute\SmallSerial(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Array => new Attribute\ArrayType(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+            ColumnType::Tuple => new Attribute\Tuple(
+                key: $key,
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions,
+                filters: $filters,
+                status: $status,
+                options: $options,
+            ),
+        };
+    }
+}
diff --git a/src/Database/Attribute/ArrayType.php b/src/Database/Attribute/ArrayType.php
new file mode 100644
index 0000000000..af43fb9004
--- /dev/null
+++ b/src/Database/Attribute/ArrayType.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class ArrayType extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Array,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/BigInteger.php b/src/Database/Attribute/BigInteger.php
new file mode 100644
index 0000000000..70b50950e0
--- /dev/null
+++ b/src/Database/Attribute/BigInteger.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class BigInteger extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::BigInteger,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/BigSerial.php b/src/Database/Attribute/BigSerial.php
new file mode 100644
index 0000000000..8aa6fa5974
--- /dev/null
+++ b/src/Database/Attribute/BigSerial.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class BigSerial extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::BigSerial,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Binary.php b/src/Database/Attribute/Binary.php
new file mode 100644
index 0000000000..ecc66b0546
--- /dev/null
+++ b/src/Database/Attribute/Binary.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Binary extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Binary,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Boolean.php b/src/Database/Attribute/Boolean.php
new file mode 100644
index 0000000000..8871a97273
--- /dev/null
+++ b/src/Database/Attribute/Boolean.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Boolean extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Boolean,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Datetime.php b/src/Database/Attribute/Datetime.php
new file mode 100644
index 0000000000..4c2d39a3a4
--- /dev/null
+++ b/src/Database/Attribute/Datetime.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Datetime extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Datetime,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Decimal.php b/src/Database/Attribute/Decimal.php
new file mode 100644
index 0000000000..a1801fbd83
--- /dev/null
+++ b/src/Database/Attribute/Decimal.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Decimal extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Decimal,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Double.php b/src/Database/Attribute/Double.php
new file mode 100644
index 0000000000..75dda9cf2a
--- /dev/null
+++ b/src/Database/Attribute/Double.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Double extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Double,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/EnumType.php b/src/Database/Attribute/EnumType.php
new file mode 100644
index 0000000000..2d34cae8be
--- /dev/null
+++ b/src/Database/Attribute/EnumType.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class EnumType extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Enum,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/FloatType.php b/src/Database/Attribute/FloatType.php
new file mode 100644
index 0000000000..4587ee95df
--- /dev/null
+++ b/src/Database/Attribute/FloatType.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class FloatType extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Float,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Id.php b/src/Database/Attribute/Id.php
new file mode 100644
index 0000000000..369d218427
--- /dev/null
+++ b/src/Database/Attribute/Id.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Id extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Id,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Integer.php b/src/Database/Attribute/Integer.php
new file mode 100644
index 0000000000..37af2bb8c5
--- /dev/null
+++ b/src/Database/Attribute/Integer.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Integer extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Integer,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Json.php b/src/Database/Attribute/Json.php
new file mode 100644
index 0000000000..2893cf0d5a
--- /dev/null
+++ b/src/Database/Attribute/Json.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Json extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Json,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Linestring.php b/src/Database/Attribute/Linestring.php
new file mode 100644
index 0000000000..bcbb0fc605
--- /dev/null
+++ b/src/Database/Attribute/Linestring.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Linestring extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Linestring,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/LongText.php b/src/Database/Attribute/LongText.php
new file mode 100644
index 0000000000..34a46efd56
--- /dev/null
+++ b/src/Database/Attribute/LongText.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class LongText extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::LongText,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/MediumText.php b/src/Database/Attribute/MediumText.php
new file mode 100644
index 0000000000..4689f4ca8c
--- /dev/null
+++ b/src/Database/Attribute/MediumText.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class MediumText extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::MediumText,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/ObjectType.php b/src/Database/Attribute/ObjectType.php
new file mode 100644
index 0000000000..b00567144c
--- /dev/null
+++ b/src/Database/Attribute/ObjectType.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class ObjectType extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Object,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Point.php b/src/Database/Attribute/Point.php
new file mode 100644
index 0000000000..70e0a6383f
--- /dev/null
+++ b/src/Database/Attribute/Point.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Point extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Point,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Polygon.php b/src/Database/Attribute/Polygon.php
new file mode 100644
index 0000000000..cb80e09a0a
--- /dev/null
+++ b/src/Database/Attribute/Polygon.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Polygon extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Polygon,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Relationship.php b/src/Database/Attribute/Relationship.php
new file mode 100644
index 0000000000..a7c6db8a94
--- /dev/null
+++ b/src/Database/Attribute/Relationship.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Relationship extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Relationship,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Serial.php b/src/Database/Attribute/Serial.php
new file mode 100644
index 0000000000..cf13bfb1fd
--- /dev/null
+++ b/src/Database/Attribute/Serial.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Serial extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Serial,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/SmallInteger.php b/src/Database/Attribute/SmallInteger.php
new file mode 100644
index 0000000000..3c6e2fea8e
--- /dev/null
+++ b/src/Database/Attribute/SmallInteger.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class SmallInteger extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::SmallInteger,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/SmallSerial.php b/src/Database/Attribute/SmallSerial.php
new file mode 100644
index 0000000000..858cfb2439
--- /dev/null
+++ b/src/Database/Attribute/SmallSerial.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class SmallSerial extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::SmallSerial,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/StringType.php b/src/Database/Attribute/StringType.php
new file mode 100644
index 0000000000..d782dabe53
--- /dev/null
+++ b/src/Database/Attribute/StringType.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Database\Database;
+use Utopia\Query\Schema\ColumnType;
+
+final class StringType extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = Database::LENGTH_KEY,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::String,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Text.php b/src/Database/Attribute/Text.php
new file mode 100644
index 0000000000..dac374f200
--- /dev/null
+++ b/src/Database/Attribute/Text.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Text extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Text,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Timestamp.php b/src/Database/Attribute/Timestamp.php
new file mode 100644
index 0000000000..4c0a300187
--- /dev/null
+++ b/src/Database/Attribute/Timestamp.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Timestamp extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Timestamp,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/TinyInteger.php b/src/Database/Attribute/TinyInteger.php
new file mode 100644
index 0000000000..f22da1a6d4
--- /dev/null
+++ b/src/Database/Attribute/TinyInteger.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class TinyInteger extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::TinyInteger,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Tuple.php b/src/Database/Attribute/Tuple.php
new file mode 100644
index 0000000000..23932eac25
--- /dev/null
+++ b/src/Database/Attribute/Tuple.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Tuple extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Tuple,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Uuid.php b/src/Database/Attribute/Uuid.php
new file mode 100644
index 0000000000..bf97935673
--- /dev/null
+++ b/src/Database/Attribute/Uuid.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Uuid extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Uuid,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Uuid7.php b/src/Database/Attribute/Uuid7.php
new file mode 100644
index 0000000000..5d41819ad8
--- /dev/null
+++ b/src/Database/Attribute/Uuid7.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Uuid7 extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Uuid7,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Varchar.php b/src/Database/Attribute/Varchar.php
new file mode 100644
index 0000000000..4b361118d9
--- /dev/null
+++ b/src/Database/Attribute/Varchar.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Database\Database;
+use Utopia\Query\Schema\ColumnType;
+
+final class Varchar extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = Database::LENGTH_KEY,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Varchar,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Attribute/Vector.php b/src/Database/Attribute/Vector.php
new file mode 100644
index 0000000000..f6e0e23c2e
--- /dev/null
+++ b/src/Database/Attribute/Vector.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database\Attribute;
+
+use Utopia\Database\Attribute as Base;
+use Utopia\Query\Schema\ColumnType;
+
+final class Vector extends Base
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        string $key = '',
+        int $size = 0,
+        bool $required = false,
+        mixed $default = null,
+        bool $signed = true,
+        bool $array = false,
+        ?string $format = null,
+        array $formatOptions = [],
+        array $filters = [],
+        ?string $status = null,
+        ?array $options = null,
+    ) {
+        parent::__construct(
+            key: $key,
+            type: ColumnType::Vector,
+            size: $size,
+            required: $required,
+            default: $default,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+}
diff --git a/src/Database/Cache/Invalidator.php b/src/Database/Cache/Invalidator.php
new file mode 100644
index 0000000000..99437428e8
--- /dev/null
+++ b/src/Database/Cache/Invalidator.php
@@ -0,0 +1,150 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+use Throwable;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Hook\Lifecycle;
+
+class Invalidator implements Lifecycle
+{
+    public function __construct(
+        private QueryCache $queryCache,
+    ) {
+    }
+
+    public function handle(Event $event, mixed $data): void
+    {
+        $tokens = $this->tokens($event, $data);
+        $this->block($tokens);
+        $this->activate($tokens);
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function tokens(Event $event, mixed $data): array
+    {
+        if (! $this->isMutation($event)) {
+            return [];
+        }
+
+        return \array_map(
+            static fn (): string => \bin2hex(\random_bytes(16)),
+            $this->extractCollections($event, $data),
+        );
+    }
+
+    /**
+     * @param  array<string, string>  $tokens
+     */
+    public function block(array $tokens): void
+    {
+        foreach ($tokens as $collection => $token) {
+            $this->queryCache->blockCollection($collection, $token);
+        }
+    }
+
+    /**
+     * @param  array<string, string>  $tokens
+     */
+    public function activate(array $tokens): void
+    {
+        $failure = null;
+        foreach ($tokens as $collection => $token) {
+            try {
+                $this->queryCache->activateCollection($collection, $token);
+            } catch (Throwable $error) {
+                $failure ??= $error;
+            }
+        }
+
+        if ($failure !== null) {
+            throw $failure;
+        }
+    }
+
+    private function isMutation(Event $event): bool
+    {
+        return \in_array($event, [
+            Event::CollectionCreate,
+            Event::CollectionUpdate,
+            Event::CollectionDelete,
+            Event::AttributeCreate,
+            Event::AttributesCreate,
+            Event::AttributeUpdate,
+            Event::AttributeDelete,
+            Event::IndexCreate,
+            Event::IndexRename,
+            Event::IndexDelete,
+            Event::DocumentPurge,
+            Event::DocumentCreate,
+            Event::DocumentsCreate,
+            Event::DocumentUpdate,
+            Event::DocumentsUpdate,
+            Event::DocumentsUpsert,
+            Event::DocumentDelete,
+            Event::DocumentsDelete,
+            Event::DocumentIncrease,
+            Event::DocumentDecrease,
+            Event::PermissionsCreate,
+            Event::PermissionsDelete,
+        ], true);
+    }
+
+    /**
+     * @return array<string, true>
+     */
+    private function extractCollections(Event $event, mixed $data): array
+    {
+        $collections = [];
+
+        if (\is_array($data)) {
+            foreach ($data as $item) {
+                foreach ($this->extractCollections($event, $item) as $collection => $present) {
+                    $collections[$collection] = $present;
+                }
+            }
+
+            return $collections;
+        }
+
+        if ($data instanceof Document) {
+            if (\in_array($event, [
+                Event::CollectionCreate,
+                Event::CollectionUpdate,
+                Event::CollectionDelete,
+            ], true)) {
+                $collection = $data->getId();
+            } else {
+                $collection = $data->getCollection();
+                if ($collection === Database::METADATA) {
+                    $collection = $data->getId();
+                }
+            }
+
+            if ($collection !== '') {
+                $collections[$collection] = true;
+            }
+
+            $options = $data->getAttribute('options', []);
+            if ($options instanceof Document) {
+                $options = $options->getArrayCopy();
+            }
+            $related = \is_array($options) ? ($options['relatedCollection'] ?? null) : null;
+            if (\is_string($related) && $related !== '') {
+                $collections[$related] = true;
+            }
+
+            return $collections;
+        }
+
+        if (\is_string($data) && $data !== '') {
+            $collections[$data] = true;
+        }
+
+        return $collections;
+    }
+}
diff --git a/src/Database/Cache/QueryCache.php b/src/Database/Cache/QueryCache.php
new file mode 100644
index 0000000000..897a9183f1
--- /dev/null
+++ b/src/Database/Cache/QueryCache.php
@@ -0,0 +1,390 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+use RuntimeException;
+use Utopia\Cache\Cache;
+use Utopia\Database\Document;
+
+class QueryCache
+{
+    private const string ACTIVE_PREFIX = 'active:';
+
+    private const string INITIAL_EPOCH = self::ACTIVE_PREFIX.'initial';
+
+    private const string BLOCKED_GENERATION = 'blocked';
+
+    private const string BLOCKED_PREFIX = 'blocked:';
+
+    private const int VERSION = 1;
+
+    /** @var array<string, Region> */
+    private array $regions = [];
+
+    private Cache $cache;
+
+    private string $cacheName;
+
+    public function __construct(Cache $cache, string $cacheName = 'default')
+    {
+        $this->cache = $cache;
+        $this->cacheName = $cacheName;
+    }
+
+    public function setRegion(string $collection, Region $region): void
+    {
+        $this->regions[$collection] = $region;
+    }
+
+    public function getRegion(string $collection): Region
+    {
+        return $this->regions[$collection] ?? new Region();
+    }
+
+    /**
+     * @param  array<mixed>  $queries
+     */
+    public function buildQueryKey(
+        string $collection,
+        array $queries,
+        string $namespace,
+        int|string|null $tenant,
+        string $context = '',
+    ): string {
+        $tenant = match (true) {
+            $tenant === null => ['type' => 'null'],
+            \is_int($tenant) => ['type' => 'integer', 'value' => $tenant],
+            default => ['type' => 'string', 'value' => $tenant],
+        };
+
+        $queriesHash = \md5(\serialize([
+            'namespace' => $namespace,
+            'tenant' => $tenant,
+            'queries' => $queries,
+            'context' => $context,
+        ]));
+
+        return "{$this->cacheName}:qcache:{$collection}#{$queriesHash}";
+    }
+
+    /**
+     * @return array<Document>|null
+     */
+    public function get(string $key): ?array
+    {
+        [$cacheKey, $hash] = $this->splitKey($key);
+        $collection = $this->getCollectionFromKey($cacheKey);
+        $epoch = $this->getEpoch($cacheKey, $collection);
+        if ($epoch === null) {
+            return null;
+        }
+        $physicalKey = $this->getPhysicalKey($cacheKey, $hash, $epoch);
+
+        /** @var mixed $data */
+        $data = $this->cache->load($physicalKey, $this->getRegion($collection)->ttl);
+
+        if ($data === false || $data === null) {
+            return null;
+        }
+
+        if ($this->getEpoch($cacheKey, $collection) !== $epoch) {
+            return null;
+        }
+
+        if (
+            ! \is_array($data)
+            || ($data['version'] ?? null) !== self::VERSION
+            || ! \is_array($data['documents'] ?? null)
+        ) {
+            $this->purgeLoadedKey($physicalKey);
+
+            return null;
+        }
+
+        $documents = [];
+        foreach ($data['documents'] as $item) {
+            if ($item instanceof Document) {
+                $documents[] = $item;
+                continue;
+            }
+
+            if (! \is_array($item)) {
+                $this->purgeLoadedKey($physicalKey);
+
+                return null;
+            }
+
+            $typed = [];
+            foreach ($item as $key => $value) {
+                if (\is_string($key)) {
+                    $typed[$key] = $value;
+                }
+            }
+            $documents[] = new Document($typed);
+        }
+
+        return $documents;
+    }
+
+    public function getGeneration(string $key): string
+    {
+        [$cacheKey, $hash] = $this->splitKey($key);
+        $collection = $this->getCollectionFromKey($cacheKey);
+        $epoch = $this->getEpoch($cacheKey, $collection, true);
+        if ($epoch === null) {
+            return self::BLOCKED_GENERATION;
+        }
+        $physicalKey = $this->getPhysicalKey($cacheKey, $hash, $epoch);
+
+        return \base64_encode(\json_encode([
+            'epoch' => $epoch,
+            'lease' => $this->cache->getGeneration($physicalKey),
+        ], JSON_THROW_ON_ERROR));
+    }
+
+    /**
+     * @param  array<mixed>  $results
+     */
+    public function set(string $key, array $results, string $generation = '0'): bool
+    {
+        if ($generation === self::BLOCKED_GENERATION) {
+            return false;
+        }
+
+        $data = [];
+        foreach ($results as $result) {
+            if (! $result instanceof Document) {
+                return false;
+            }
+
+            $data[] = $result->getArrayCopy();
+        }
+
+        [$cacheKey, $hash] = $this->splitKey($key);
+        $collection = $this->getCollectionFromKey($cacheKey);
+        $decoded = $this->decodeGeneration($generation, $cacheKey, $hash, $collection);
+        if ($decoded === null) {
+            return false;
+        }
+        [$epoch, $lease] = $decoded;
+        if ($this->getEpoch($cacheKey, $collection) !== $epoch) {
+            return false;
+        }
+        $physicalKey = $this->getPhysicalKey($cacheKey, $hash, $epoch);
+
+        return $this->cache->saveWithLease($physicalKey, [
+            'version' => self::VERSION,
+            'documents' => $data,
+        ], '', $lease) !== false;
+    }
+
+    public function invalidateCollection(string $collection): void
+    {
+        $token = \bin2hex(\random_bytes(16));
+        $this->blockCollection($collection, $token);
+        $this->activateCollection($collection, $token);
+    }
+
+    /**
+     * Publish a shared tombstone before a mutation starts.
+     */
+    public function blockCollection(string $collection, string $token): void
+    {
+        $cacheKey = $this->getCollectionKey($collection);
+        $ownerKey = $this->getOwnerKey($cacheKey, $token);
+        if ($this->cache->save($ownerKey, $token) === false) {
+            throw new RuntimeException("Failed to register query cache owner for collection '{$collection}'");
+        }
+
+        $startedKey = $this->getStartedKey($cacheKey);
+        $started = $this->cache->getGeneration($startedKey);
+        $this->cache->purge($startedKey);
+        $advanced = $this->cache->getGeneration($startedKey) !== $started;
+
+        $epochKey = $this->getEpochKey($cacheKey);
+        $existing = $this->cache->load($epochKey, $this->getRegion($collection)->ttl);
+
+        $purged = $existing === false || $existing === null || $this->cache->purge($epochKey);
+
+        if ($this->cache->save($epochKey, self::BLOCKED_PREFIX.$token) === false) {
+            throw new RuntimeException("Failed to block query cache for collection '{$collection}'");
+        }
+
+        if (! $purged) {
+            throw new RuntimeException("Failed to purge query cache epoch for collection '{$collection}'");
+        }
+
+        if (! $advanced) {
+            return;
+        }
+    }
+
+    /**
+     * Replace this mutation's shared tombstone with a fresh usable epoch.
+     */
+    public function activateCollection(string $collection, string $token): void
+    {
+        $cacheKey = $this->getCollectionKey($collection);
+        $ownerKey = $this->getOwnerKey($cacheKey, $token);
+        if ($this->cache->load($ownerKey, $this->getRegion($collection)->ttl) !== $token) {
+            throw new RuntimeException("Invalid query cache owner for collection '{$collection}'");
+        }
+        if (! $this->cache->purge($ownerKey)) {
+            throw new RuntimeException("Failed to release query cache owner for collection '{$collection}'");
+        }
+
+        $startedKey = $this->getStartedKey($cacheKey);
+        $finishedKey = $this->getFinishedKey($cacheKey);
+        if ($this->cache->getGeneration($startedKey) === $this->cache->getGeneration($finishedKey)) {
+            return;
+        }
+
+        $epochKey = $this->getEpochKey($cacheKey);
+        $epoch = self::ACTIVE_PREFIX.\bin2hex(\random_bytes(16));
+        if ($this->cache->save($epochKey, $epoch) === false) {
+            throw new RuntimeException("Failed to activate query cache for collection '{$collection}'");
+        }
+
+        $finished = $this->cache->getGeneration($finishedKey);
+        $this->cache->purge($finishedKey);
+        if ($this->cache->getGeneration($finishedKey) === $finished) {
+            throw new RuntimeException("Failed to finish query cache invalidation for collection '{$collection}'");
+        }
+    }
+
+    public function isEnabled(string $collection): bool
+    {
+        $region = $this->getRegion($collection);
+
+        if (! $region->enabled) {
+            return false;
+        }
+
+        return $this->getEpoch($this->getCollectionKey($collection), $collection) !== null;
+    }
+
+    public function flush(): void
+    {
+        if (! $this->cache->flush()) {
+            throw new RuntimeException('Failed to flush query cache');
+        }
+    }
+
+    private function getCollectionKey(string $collection): string
+    {
+        return "{$this->cacheName}:qcache:{$collection}";
+    }
+
+    private function getCollectionFromKey(string $key): string
+    {
+        $prefix = "{$this->cacheName}:qcache:";
+
+        return \str_starts_with($key, $prefix) ? \substr($key, \strlen($prefix)) : '';
+    }
+
+    /** @return array{string, string} */
+    private function splitKey(string $key): array
+    {
+        $parts = \explode('#', $key, 2);
+
+        return [$parts[0], $parts[1] ?? ''];
+    }
+
+    private function getEpoch(string $cacheKey, string $collection, bool $initialize = false): ?string
+    {
+        $startedKey = $this->getStartedKey($cacheKey);
+        $finishedKey = $this->getFinishedKey($cacheKey);
+        $started = $this->cache->getGeneration($startedKey);
+        $finished = $this->cache->getGeneration($finishedKey);
+        if ($started !== $finished) {
+            return null;
+        }
+
+        $epoch = $this->cache->load(
+            $this->getEpochKey($cacheKey),
+            $this->getRegion($collection)->ttl,
+        );
+
+        if ($epoch === false || $epoch === null) {
+            $epoch = self::INITIAL_EPOCH;
+        }
+
+        if (! \is_string($epoch) || $epoch === '') {
+            throw new RuntimeException("Invalid query cache epoch for collection '{$collection}'");
+        }
+
+        $nextStarted = $this->cache->getGeneration($startedKey);
+        $nextFinished = $this->cache->getGeneration($finishedKey);
+        if (
+            $started !== $nextStarted
+            || $finished !== $nextFinished
+            || $nextStarted !== $nextFinished
+            || ! \str_starts_with($epoch, self::ACTIVE_PREFIX)
+        ) {
+            return null;
+        }
+
+        return $epoch;
+    }
+
+    private function getEpochKey(string $cacheKey): string
+    {
+        return $cacheKey.'#epoch';
+    }
+
+    private function getFinishedKey(string $cacheKey): string
+    {
+        return $cacheKey.'#finished';
+    }
+
+    private function getOwnerKey(string $cacheKey, string $token): string
+    {
+        return $cacheKey.'#owner:'.$token;
+    }
+
+    private function getStartedKey(string $cacheKey): string
+    {
+        return $cacheKey.'#started';
+    }
+
+    private function getPhysicalKey(string $cacheKey, string $hash, string $epoch): string
+    {
+        return $cacheKey.'#'.$epoch.':'.$hash;
+    }
+
+    private function purgeLoadedKey(string $physicalKey): void
+    {
+        if (! $this->cache->purge($physicalKey)) {
+            throw new RuntimeException("Failed to purge invalid query cache entry '{$physicalKey}'");
+        }
+    }
+
+    /** @return array{string, string}|null */
+    private function decodeGeneration(
+        string $generation,
+        string $cacheKey,
+        string $hash,
+        string $collection,
+    ): ?array {
+        if ($generation === '0') {
+            $epoch = $this->getEpoch($cacheKey, $collection, true);
+            if ($epoch === null) {
+                return null;
+            }
+            $physicalKey = $this->getPhysicalKey($cacheKey, $hash, $epoch);
+
+            return [$epoch, $this->cache->getGeneration($physicalKey)];
+        }
+
+        $encoded = \base64_decode($generation, true);
+        $decoded = $encoded === false ? null : \json_decode($encoded, true);
+        $epoch = \is_array($decoded) ? ($decoded['epoch'] ?? null) : null;
+        $lease = \is_array($decoded) ? ($decoded['lease'] ?? null) : null;
+
+        if (! \is_string($epoch) || $epoch === '' || ! \is_string($lease)) {
+            throw new RuntimeException('Invalid query cache generation');
+        }
+
+        return [$epoch, $lease];
+    }
+}
diff --git a/src/Database/Cache/Region.php b/src/Database/Cache/Region.php
new file mode 100644
index 0000000000..4772cef3fe
--- /dev/null
+++ b/src/Database/Cache/Region.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+class Region
+{
+    public function __construct(
+        public int $ttl = 3600,
+        public bool $enabled = true,
+    ) {
+    }
+}
diff --git a/src/Database/Capability.php b/src/Database/Capability.php
new file mode 100644
index 0000000000..e49e346c33
--- /dev/null
+++ b/src/Database/Capability.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the set of optional behavioral capabilities that a database adapter may support.
+ *
+ * Feature availability (method contracts) is expressed via Feature interfaces
+ * on the adapter class and checked with instanceof, not capabilities.
+ */
+enum Capability
+{
+    case AlterLock;
+    case AttributeResizing;
+    case BatchCreateAttributes;
+    case BatchOperations;
+    case BoundaryInclusive;
+    case Caching;
+    case CacheSkipOnFailure;
+    case CastIndexArray;
+    case Casting;
+    case DefinedAttributes;
+    case Fulltext;
+    case FulltextWildcard;
+    case Hostname;
+    case IdenticalIndexes;
+    case Index;
+    case IndexArray;
+    case IntegerBooleans;
+    case JSONOverlaps;
+    case MultiDimensionDistance;
+    case MultipleFulltextIndexes;
+    case NestedTransactions;
+    case NumericCasting;
+    case ObjectIndexes;
+    case Objects;
+    case Operators;
+    case OptionalSpatial;
+    case OrderRandom;
+    case PCRE;
+    case POSIX;
+    case QueryContains;
+    case Reconnection;
+    case Regex;
+    case Schemas;
+    case SpatialAxisOrder;
+    case SpatialIndexNull;
+    case SpatialIndexOrder;
+    case TTLIndexes;
+    case TransactionRetries;
+    case TrigramIndex;
+    case UniqueIndex;
+    case UpdateLock;
+    case Upserts;
+    case UpsertOnUniqueIndex;
+    case UnsignedBigInt;
+    case Vectors;
+    case Joins;
+    case Aggregations;
+    case Subqueries;
+    case CTEs;
+    case WindowFunctions;
+}
diff --git a/src/Database/Change.php b/src/Database/Change.php
index e57dd16cf2..718278587f 100644
--- a/src/Database/Change.php
+++ b/src/Database/Change.php
@@ -2,6 +2,9 @@
 
 namespace Utopia\Database;
 
+/**
+ * Represents a document change, holding both the old and new versions of a document.
+ */
 class Change
 {
     public function __construct(
@@ -10,21 +13,43 @@ public function __construct(
     ) {
     }
 
+    /**
+     * Get the old document before the change.
+     *
+     * @return Document
+     */
     public function getOld(): Document
     {
         return $this->old;
     }
 
+    /**
+     * Set the old document before the change.
+     *
+     * @param Document $old The previous document state
+     * @return void
+     */
     public function setOld(Document $old): void
     {
         $this->old = $old;
     }
 
+    /**
+     * Get the new document after the change.
+     *
+     * @return Document
+     */
     public function getNew(): Document
     {
         return $this->new;
     }
 
+    /**
+     * Set the new document after the change.
+     *
+     * @param Document $new The updated document state
+     * @return void
+     */
     public function setNew(Document $new): void
     {
         $this->new = $new;
diff --git a/src/Database/Collection.php b/src/Database/Collection.php
new file mode 100644
index 0000000000..b5c4a056bd
--- /dev/null
+++ b/src/Database/Collection.php
@@ -0,0 +1,234 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+
+/**
+ * A collection metadata document. Nested attributes and indexes are Attribute and Index models.
+ *
+ * @property string $id
+ * @property string $name
+ * @property array<Attribute> $attributes
+ * @property array<Index> $indexes
+ * @property array<string>|null $permissions
+ * @property bool $documentSecurity
+ * @property array<string, mixed> $metadata
+ */
+class Collection extends Document
+{
+    /**
+     * @param  array<Attribute|Document|array<string, mixed>>  $attributes
+     * @param  array<Index|Document|array<string, mixed>>  $indexes
+     * @param  array<string>|null  $permissions  Null means default create-any; empty means none
+     * @param  array<string, mixed>  $metadata
+     */
+    public function __construct(
+        string $id = '',
+        string $name = '',
+        array $attributes = [],
+        array $indexes = [],
+        ?array $permissions = null,
+        bool $documentSecurity = true,
+        public array $metadata = [],
+    ) {
+        $data = [
+            self::ID => ID::custom($id),
+            'name' => $name !== '' ? $name : $id,
+            'attributes' => self::castAttributes($attributes),
+            'indexes' => self::castIndexes($indexes),
+        ];
+        if ($id !== '') {
+            $data['documentSecurity'] = $documentSecurity;
+        }
+        if ($permissions !== null) {
+            $data[self::PERMISSIONS] = $permissions;
+        }
+
+        parent::__construct(\array_merge($data, $this->metadata));
+    }
+
+    public function isEmpty(): bool
+    {
+        return $this->getId() === '';
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public static function fromArray(array $data): self
+    {
+        $id = $data[self::ID] ?? '';
+        if (! \is_string($id)) {
+            $id = '';
+        }
+
+        $name = $data['name'] ?? $id;
+        if (! \is_string($name)) {
+            $name = $id;
+        }
+
+        $permissions = null;
+        if (\array_key_exists(self::PERMISSIONS, $data) && \is_array($data[self::PERMISSIONS])) {
+            /** @var array<string> $permissions */
+            $permissions = $data[self::PERMISSIONS];
+        }
+
+        $rawAttributes = $data['attributes'] ?? [];
+        $rawIndexes = $data['indexes'] ?? [];
+
+        $collection = new self(
+            id: $id,
+            name: $name,
+            attributes: \is_array($rawAttributes) ? self::castAttributes($rawAttributes) : [],
+            indexes: \is_array($rawIndexes) ? self::castIndexes($rawIndexes) : [],
+            permissions: $permissions,
+            documentSecurity: (bool) ($data['documentSecurity'] ?? true),
+        );
+
+        if (\is_string($rawAttributes)) {
+            $collection->setAttribute('attributes', $rawAttributes);
+        }
+        if (\is_string($rawIndexes)) {
+            $collection->setAttribute('indexes', $rawIndexes);
+        }
+
+        foreach ($data as $key => $value) {
+            if (\in_array($key, [self::ID, 'name', 'attributes', 'indexes', self::PERMISSIONS, 'documentSecurity'], true)) {
+                continue;
+            }
+            $collection->setAttribute($key, $value);
+        }
+
+        return $collection;
+    }
+
+    /**
+     * @return (
+     *     $name is 'id' ? string :
+     *     $name is 'name' ? string :
+     *     $name is 'attributes' ? array<Attribute> :
+     *     $name is 'indexes' ? array<Index> :
+     *     $name is 'permissions' ? array<string>|null :
+     *     $name is 'documentSecurity' ? bool :
+     *     mixed
+     * )
+     */
+    public function __get(string $name): mixed
+    {
+        switch ($name) {
+            case 'id':
+                return $this->getId();
+            case 'name':
+                /** @var string $value */
+                $value = $this->getAttribute('name', $this->getId());
+
+                return $value;
+            case 'attributes':
+                return self::castAttributes($this->getArray('attributes'));
+            case 'indexes':
+                return self::castIndexes($this->getArray('indexes'));
+            case 'permissions':
+                return $this->offsetExists(self::PERMISSIONS) ? $this->getPermissions() : null;
+            case 'documentSecurity':
+                return (bool) $this->getAttribute('documentSecurity', true);
+            default:
+                return $this->getAttribute($name);
+        }
+    }
+
+    public function __set(string $name, mixed $value): void
+    {
+        match ($name) {
+            'id' => $this->setAttribute(self::ID, $value),
+            'name' => $this->setAttribute('name', $value),
+            'attributes' => $this->setAttribute('attributes', $value),
+            'indexes' => $this->setAttribute('indexes', $value),
+            'permissions' => $this->setAttribute(self::PERMISSIONS, $value ?? []),
+            'documentSecurity' => $this->setAttribute('documentSecurity', $value),
+            default => $this->setAttribute($name, $value),
+        };
+    }
+
+    public function __isset(string $name): bool
+    {
+        return match ($name) {
+            'id', 'name', 'attributes', 'indexes', 'permissions', 'documentSecurity', 'metadata' => true,
+            default => $this->offsetExists($name),
+        };
+    }
+
+    /**
+     * @param  mixed  $attributes
+     * @return array<Attribute>
+     */
+    private static function castAttributes(mixed $attributes): array
+    {
+        if (! \is_array($attributes)) {
+            return [];
+        }
+
+        $cast = [];
+        foreach ($attributes as $attr) {
+            if ($attr instanceof Attribute) {
+                $cast[] = $attr;
+
+                continue;
+            }
+            if ($attr instanceof Document) {
+                $cast[] = Attribute::fromArray($attr->getArrayCopy());
+
+                continue;
+            }
+            if (! \is_array($attr)) {
+                throw new \InvalidArgumentException('Collection attributes must be Attribute models');
+            }
+            $typed = [];
+            foreach ($attr as $name => $item) {
+                if (\is_string($name)) {
+                    $typed[$name] = $item;
+                }
+            }
+            $cast[] = Attribute::fromArray($typed);
+        }
+
+        return $cast;
+    }
+
+    /**
+     * @param  mixed  $indexes
+     * @return array<Index>
+     */
+    private static function castIndexes(mixed $indexes): array
+    {
+        if (! \is_array($indexes)) {
+            return [];
+        }
+
+        $cast = [];
+        foreach ($indexes as $idx) {
+            if ($idx instanceof Index) {
+                $cast[] = $idx;
+
+                continue;
+            }
+            if ($idx instanceof Document) {
+                $cast[] = Index::fromArray($idx->getArrayCopy());
+
+                continue;
+            }
+            if (! \is_array($idx)) {
+                throw new \InvalidArgumentException('Collection indexes must be Index models');
+            }
+            $typed = [];
+            foreach ($idx as $name => $item) {
+                if (\is_string($name)) {
+                    $typed[$name] = $item;
+                }
+            }
+            $cast[] = Index::fromArray($typed);
+        }
+
+        return $cast;
+    }
+}
diff --git a/src/Database/Connection.php b/src/Database/Connection.php
index 474d10a7f6..024aecc266 100644
--- a/src/Database/Connection.php
+++ b/src/Database/Connection.php
@@ -3,23 +3,27 @@
 namespace Utopia\Database;
 
 use Swoole\Database\DetectsLostConnections;
+use Throwable;
 
+/**
+ * Provides utilities for detecting lost database connections.
+ */
 class Connection
 {
     /**
      * @var array<string>
      */
     protected static array $errors = [
-        'Max connect timeout reached'
+        'Max connect timeout reached',
     ];
 
     /**
      * Check if the given throwable was caused by a database connection error.
      *
-     * @param \Throwable $e
+     * @param Throwable $e The exception to inspect
      * @return bool
      */
-    public static function hasError(\Throwable $e): bool
+    public static function hasError(Throwable $e): bool
     {
         if (DetectsLostConnections::causedByLostConnection($e)) {
             return true;
diff --git a/src/Database/Database.php b/src/Database/Database.php
index 4769599a99..b44048b818 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -2,120 +2,62 @@
 
 namespace Utopia\Database;
 
+use DateTime as NativeDateTime;
+use DateTimeZone;
 use Exception;
 use Swoole\Coroutine;
 use Throwable;
 use Utopia\Cache\Cache;
 use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Cache\Invalidator;
+use Utopia\Database\Cache\QueryCache;
 use Utopia\Database\Exception as DatabaseException;
-use Utopia\Database\Exception\Authorization as AuthorizationException;
-use Utopia\Database\Exception\Conflict as ConflictException;
-use Utopia\Database\Exception\Dependency as DependencyException;
-use Utopia\Database\Exception\Duplicate as DuplicateException;
-use Utopia\Database\Exception\Index as IndexException;
-use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
-use Utopia\Database\Exception\Order as OrderException;
 use Utopia\Database\Exception\Query as QueryException;
-use Utopia\Database\Exception\Relationship as RelationshipException;
-use Utopia\Database\Exception\Restricted as RestrictedException;
 use Utopia\Database\Exception\Structure as StructureException;
-use Utopia\Database\Exception\Timeout as TimeoutException;
-use Utopia\Database\Exception\Type as TypeException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
-use Utopia\Database\Helpers\Role;
-use Utopia\Database\Validator\Attribute as AttributeValidator;
+use Utopia\Database\Hook\Lifecycle;
+use Utopia\Database\Hook\Relationships;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Profiler\QueryProfiler;
+use Utopia\Database\Type\TypeRegistry;
 use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\Authorization\Input;
-use Utopia\Database\Validator\BigInt as BigIntValidator;
-use Utopia\Database\Validator\Index as IndexValidator;
-use Utopia\Database\Validator\IndexDependency as IndexDependencyValidator;
-use Utopia\Database\Validator\PartialStructure;
-use Utopia\Database\Validator\Permissions;
-use Utopia\Database\Validator\Queries\Document as DocumentValidator;
-use Utopia\Database\Validator\Queries\Documents as DocumentsValidator;
-use Utopia\Database\Validator\Spatial;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Database\Validator\Spatial as SpatialValidator;
 use Utopia\Database\Validator\Structure;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 
+/**
+ * High-level database interface providing CRUD operations for documents, collections, attributes, indexes, and relationships with built-in caching, filtering, validation, and authorization.
+ */
 class Database
 {
-    // Simple Types
-    public const VAR_STRING = 'string';
-    public const VAR_INTEGER = 'integer';
-    public const VAR_BIGINT = 'bigint';
-    public const VAR_FLOAT = 'double';
-    public const VAR_BOOLEAN = 'boolean';
-    public const VAR_DATETIME = 'datetime';
-
-    public const VAR_VARCHAR = 'varchar';
-    public const VAR_TEXT = 'text';
-    public const VAR_MEDIUMTEXT = 'mediumtext';
-    public const VAR_LONGTEXT = 'longtext';
-
-    // ID types
-    public const VAR_ID = 'id';
-    public const VAR_UUID7 = 'uuid7';
-
-    // object type
-    public const VAR_OBJECT = 'object';
-
-    // Vector types
-    public const VAR_VECTOR = 'vector';
-
-    // Vector query result key
-    public const VECTOR_DISTANCE = '$distance';
-
-    // Relationship Types
-    public const VAR_RELATIONSHIP = 'relationship';
-
-    // Spatial Types
-    public const VAR_POINT = 'point';
-    public const VAR_LINESTRING = 'linestring';
-    public const VAR_POLYGON = 'polygon';
-
-    // All string types
-    public const STRING_TYPES = [
-        self::VAR_STRING,
-        self::VAR_VARCHAR,
-        self::VAR_TEXT,
-        self::VAR_MEDIUMTEXT,
-        self::VAR_LONGTEXT,
-    ];
-
-    // All spatial types
-    public const SPATIAL_TYPES = [
-        self::VAR_POINT,
-        self::VAR_LINESTRING,
-        self::VAR_POLYGON
-    ];
-
-    // All types which requires filters
-    public const ATTRIBUTE_FILTER_TYPES = [
-        ...self::SPATIAL_TYPES,
-        self::VAR_VECTOR,
-        self::VAR_OBJECT,
-        self::VAR_DATETIME
-    ];
-
-    // Index Types
-    public const INDEX_KEY = 'key';
-    public const INDEX_FULLTEXT = 'fulltext';
-    public const INDEX_UNIQUE = 'unique';
-    public const INDEX_SPATIAL = 'spatial';
-    public const INDEX_OBJECT = 'object';
-    public const INDEX_HNSW_EUCLIDEAN = 'hnsw_euclidean';
-    public const INDEX_HNSW_COSINE = 'hnsw_cosine';
-    public const INDEX_HNSW_DOT = 'hnsw_dot';
-    public const INDEX_TRIGRAM = 'trigram';
-    public const INDEX_TTL = 'ttl';
+    use Traits\Async;
+    use Traits\Attributes;
+    use Traits\Collections;
+    use Traits\Databases;
+    use Traits\Documents;
+    use Traits\Indexes;
+    use Traits\Relationships;
+    use Traits\Transactions;
 
     // Max limits
     public const MAX_INT = 2147483647;
+
     public const MAX_BIG_INT = PHP_INT_MAX;
+
     public const MAX_DOUBLE = PHP_FLOAT_MAX;
+
     public const MAX_VECTOR_DIMENSIONS = 16000;
+
+    public const string VECTOR_DISTANCE = Document::DISTANCE;
+
     public const MAX_ARRAY_INDEX_LENGTH = 255;
+
     public const MAX_UID_DEFAULT_LENGTH = 36;
 
     // Maximum byte capacity for TEXT
@@ -128,53 +70,14 @@ class Database
 
     // Global SRID for geographic coordinates (WGS84)
     public const DEFAULT_SRID = 4326;
-    public const EARTH_RADIUS = 6371000;
-
-    // Relation Types
-    public const RELATION_ONE_TO_ONE = 'oneToOne';
-    public const RELATION_ONE_TO_MANY = 'oneToMany';
-    public const RELATION_MANY_TO_ONE = 'manyToOne';
-    public const RELATION_MANY_TO_MANY = 'manyToMany';
 
-    // Relation Actions
-    public const RELATION_MUTATE_CASCADE = 'cascade';
-    public const RELATION_MUTATE_RESTRICT = 'restrict';
-    public const RELATION_MUTATE_SET_NULL = 'setNull';
-
-    // Relation Sides
-    public const RELATION_SIDE_PARENT = 'parent';
-    public const RELATION_SIDE_CHILD = 'child';
+    public const EARTH_RADIUS = 6371000;
 
     public const RELATION_MAX_DEPTH = 3;
-    public const RELATION_QUERY_CHUNK_SIZE = 5000;
-
-    // Orders
-    public const ORDER_ASC = 'ASC';
-    public const ORDER_DESC = 'DESC';
-    public const ORDER_RANDOM = 'RANDOM';
-
-    // Permissions
-    public const PERMISSION_CREATE = 'create';
-    public const PERMISSION_READ = 'read';
-    public const PERMISSION_UPDATE = 'update';
-    public const PERMISSION_DELETE = 'delete';
-
-    // Aggregate permissions
-    public const PERMISSION_WRITE = 'write';
-
-    public const PERMISSIONS = [
-        self::PERMISSION_CREATE,
-        self::PERMISSION_READ,
-        self::PERMISSION_UPDATE,
-        self::PERMISSION_DELETE,
-    ];
 
-    // Collections
-    public const METADATA = '_metadata';
+    public const RELATION_QUERY_CHUNK_SIZE = 5000;
 
-    // Cursor
-    public const CURSOR_BEFORE = 'before';
-    public const CURSOR_AFTER = 'after';
+    public const string METADATA = '_metadata';
 
     // Lengths
     public const LENGTH_KEY = 255;
@@ -182,51 +85,10 @@ class Database
     // Cache
     public const TTL = 60 * 60 * 24; // 24 hours
 
-    // Cache "Not Found" results
     private const CACHE_EMPTY_MARKER = '$empty';
 
-    // Events
-    public const EVENT_ALL = '*';
-
-    public const EVENT_DATABASE_LIST = 'database_list';
-    public const EVENT_DATABASE_CREATE = 'database_create';
-    public const EVENT_DATABASE_DELETE = 'database_delete';
-
-    public const EVENT_COLLECTION_LIST = 'collection_list';
-    public const EVENT_COLLECTION_CREATE = 'collection_create';
-    public const EVENT_COLLECTION_UPDATE = 'collection_update';
-    public const EVENT_COLLECTION_READ = 'collection_read';
-    public const EVENT_COLLECTION_DELETE = 'collection_delete';
-
-    public const EVENT_DOCUMENT_FIND = 'document_find';
-    public const EVENT_DOCUMENT_PURGE = 'document_purge';
-    public const EVENT_DOCUMENT_CREATE = 'document_create';
-    public const EVENT_DOCUMENTS_CREATE = 'documents_create';
-    public const EVENT_DOCUMENT_READ = 'document_read';
-    public const EVENT_DOCUMENT_UPDATE = 'document_update';
-    public const EVENT_DOCUMENTS_UPDATE = 'documents_update';
-    public const EVENT_DOCUMENTS_UPSERT = 'documents_upsert';
-    public const EVENT_DOCUMENT_DELETE = 'document_delete';
-    public const EVENT_DOCUMENTS_DELETE = 'documents_delete';
-    public const EVENT_DOCUMENT_COUNT = 'document_count';
-    public const EVENT_DOCUMENT_SUM = 'document_sum';
-    public const EVENT_DOCUMENT_INCREASE = 'document_increase';
-    public const EVENT_DOCUMENT_DECREASE = 'document_decrease';
-
-    public const EVENT_PERMISSIONS_CREATE = 'permissions_create';
-    public const EVENT_PERMISSIONS_READ = 'permissions_read';
-    public const EVENT_PERMISSIONS_DELETE = 'permissions_delete';
-
-    public const EVENT_ATTRIBUTE_CREATE = 'attribute_create';
-    public const EVENT_ATTRIBUTES_CREATE = 'attributes_create';
-    public const EVENT_ATTRIBUTE_UPDATE = 'attribute_update';
-    public const EVENT_ATTRIBUTE_DELETE = 'attribute_delete';
-
-    public const EVENT_INDEX_RENAME = 'index_rename';
-    public const EVENT_INDEX_CREATE = 'index_create';
-    public const EVENT_INDEX_DELETE = 'index_delete';
-
     public const INSERT_BATCH_SIZE = 1_000;
+
     public const DELETE_BATCH_SIZE = 1_000;
 
     /**
@@ -236,8 +98,8 @@ class Database
      */
     public const INTERNAL_ATTRIBUTES = [
         [
-            '$id' => '$id',
-            'type' => self::VAR_STRING,
+            Document::ID => Document::ID,
+            'type' => ColumnType::String->value,
             'size' => Database::LENGTH_KEY,
             'required' => true,
             'signed' => true,
@@ -245,8 +107,8 @@ class Database
             'filters' => [],
         ],
         [
-            '$id' => '$sequence',
-            'type' => self::VAR_ID,
+            Document::ID => Document::SEQUENCE,
+            'type' => ColumnType::Id->value,
             'size' => 0,
             'required' => true,
             'signed' => true,
@@ -254,8 +116,8 @@ class Database
             'filters' => [],
         ],
         [
-            '$id' => '$collection',
-            'type' => self::VAR_STRING,
+            Document::ID => Document::COLLECTION,
+            'type' => ColumnType::String->value,
             'size' => Database::LENGTH_KEY,
             'required' => true,
             'signed' => true,
@@ -263,8 +125,8 @@ class Database
             'filters' => [],
         ],
         [
-            '$id' => '$tenant',
-            'type' => self::VAR_ID,
+            Document::ID => Document::TENANT,
+            'type' => ColumnType::Id->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -273,108 +135,64 @@ class Database
             'filters' => [],
         ],
         [
-            '$id' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::CREATED_AT,
+            'type' => ColumnType::Datetime->value,
             'format' => '',
             'size' => 0,
             'signed' => false,
             'required' => false,
             'default' => null,
             'array' => false,
-            'filters' => ['datetime']
+            'filters' => ['datetime'],
         ],
         [
-            '$id' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::UPDATED_AT,
+            'type' => ColumnType::Datetime->value,
             'format' => '',
             'size' => 0,
             'signed' => false,
             'required' => false,
             'default' => null,
             'array' => false,
-            'filters' => ['datetime']
+            'filters' => ['datetime'],
         ],
         [
-            '$id' => '$permissions',
-            'type' => Database::VAR_STRING,
+            Document::ID => Document::PERMISSIONS,
+            'type' => ColumnType::String->value,
             'size' => 1_000_000,
             'signed' => true,
             'required' => false,
             'default' => [],
             'array' => false,
-            'filters' => ['json']
+            'filters' => ['json'],
+        ],
+        [
+            Document::ID => Document::VERSION,
+            'type' => ColumnType::Integer->value,
+            'size' => 0,
+            'required' => false,
+            'default' => null,
+            'signed' => false,
+            'array' => false,
+            'filters' => [],
         ],
     ];
 
     public const INTERNAL_ATTRIBUTE_KEYS = [
-        '_uid',
-        '_createdAt',
-        '_updatedAt',
-        '_permissions',
+        Storage::UID,
+        Storage::CREATED_AT,
+        Storage::UPDATED_AT,
+        Storage::PERMISSIONS,
+        Storage::VERSION,
     ];
 
     public const INTERNAL_INDEXES = [
-        '_id',
-        '_uid',
-        '_createdAt',
-        '_updatedAt',
-        '_permissions_id',
-        '_permissions',
-    ];
-
-    /**
-     * Parent Collection
-     * Defines the structure for both system and custom collections
-     *
-     * @var array<string, mixed>
-     */
-    protected const COLLECTION = [
-        '$id' => self::METADATA,
-        '$collection' => self::METADATA,
-        'name' => 'collections',
-        'attributes' => [
-            [
-                '$id' => 'name',
-                'key' => 'name',
-                'type' => self::VAR_STRING,
-                'size' => 256,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ],
-            [
-                '$id' => 'attributes',
-                'key' => 'attributes',
-                'type' => self::VAR_STRING,
-                'size' => 1000000,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => ['json'],
-            ],
-            [
-                '$id' => 'indexes',
-                'key' => 'indexes',
-                'type' => self::VAR_STRING,
-                'size' => 1000000,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => ['json'],
-            ],
-            [
-                '$id' => 'documentSecurity',
-                'key' => 'documentSecurity',
-                'type' => self::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => []
-            ]
-        ],
-        'indexes' => [],
+        Storage::SEQUENCE,
+        Storage::UID,
+        Storage::CREATED_AT,
+        Storage::UPDATED_AT,
+        Storage::INDEX_PERMISSIONS_ID,
+        Storage::PERMISSIONS,
     ];
 
     protected Adapter $adapter;
@@ -389,35 +207,60 @@ class Database
     protected static array $filters = [];
 
     /**
-     * @var array<string, array{encode: callable, decode: callable, signature: string}>
+     * Process-lifetime cache of internal attribute definitions as typed Attribute objects.
+     * Built once from {@see self::INTERNAL_ATTRIBUTES} (a class constant) and reused across calls.
+     *
+     * Returned arrays/objects MUST NOT be mutated by callers — they are shared singletons.
+     *
+     * @var array<Attribute>|null
      */
-    protected array $instanceFilters = [];
+    private static ?array $internalAttributes = null;
 
     /**
-     * @var array<string, array<string, callable>>
+     * Process-lifetime cache of internal attribute definitions as Document instances.
+     * Built once from {@see self::INTERNAL_ATTRIBUTES} (a class constant) and reused across calls.
+     *
+     * Returned Documents MUST NOT be mutated by callers — they are shared singletons.
+     *
+     * @var array<Document>|null
      */
-    protected array $listeners = [
-        '*' => [],
-    ];
+    private static ?array $internalAttributeDocuments = null;
 
     /**
-     * Array in which the keys are the names of database listeners that
-     * should be skipped when dispatching events. null $silentListeners
-     * will skip all listeners.
+     * Process-lifetime cache of internal attribute definitions as raw arrays, keyed by
+     * whether the adapter has shared tables enabled. The shared-tables variant includes
+     * `$tenant`, the other variant excludes it.
      *
-     * @var ?array<string, bool>
+     * Returned arrays MUST NOT be mutated by callers — they are shared singletons.
+     *
+     * @var array<int, array<array<string, mixed>>>|null
+     */
+    private static ?array $internalAttributeArrays = null;
+
+    /**
+     * @var array<string, array{encode: callable, decode: callable, signature: string}>
+     */
+    protected array $instanceFilters = [];
+
+    /**
+     * @var array<Lifecycle>
      */
-    protected ?array $silentListeners = [];
+    protected array $lifecycleHooks = [];
 
-    protected ?\DateTime $timestamp = null;
+    /**
+     * @var array<Hook\Decorator>
+     */
+    protected array $decorators = [];
 
-    protected bool $resolveRelationships = true;
+    /** @var array<int, int> Lifecycle silence depth by coroutine id. */
+    protected array $silencedEvents = [];
 
-    protected bool $checkRelationshipsExist = true;
+    /** @var array<int, array<string, string>> Pending query-cache tombstones by coroutine id. */
+    protected array $queryCacheMutations = [];
 
-    protected int $relationshipFetchDepth = 0;
+    protected ?NativeDateTime $timestamp = null;
 
-    protected bool $inBatchRelationshipPopulation = false;
+    protected ?Relationships $relationshipHook = null;
 
     protected bool $filter = true;
 
@@ -432,10 +275,10 @@ class Database
 
     protected bool $preserveDates = false;
 
-    protected bool $skipDuplicates = false;
-
     protected bool $preserveSequence = false;
 
+    protected bool $skipDuplicates = false;
+
     protected int $maxQueryValues = 5000;
 
     protected bool $migrating = false;
@@ -447,38 +290,29 @@ class Database
      */
     protected array $globalCollections = [];
 
-    /**
-     * Stack of collection IDs when creating or updating related documents
-     * @var array<string>
-     */
-    protected array $relationshipWriteStack = [];
-
-    /**
-     * @var array<Document>
-     */
-    protected array $relationshipFetchStack = [];
-
-    /**
-     * @var array<Document>
-     */
-    protected array $relationshipDeleteStack = [];
-
     /**
      * Type mapping for collections to custom document classes
+     *
      * @var array<string, class-string<Document>>
      */
     protected array $documentTypes = [];
 
+    protected ?TypeRegistry $typeRegistry = null;
+
+    protected ?QueryCache $queryCache = null;
+
+    protected ?Invalidator $queryCacheInvalidator = null;
+
+    protected ?QueryProfiler $profiler = null;
 
-    /**
-     * @var Authorization
-     */
     private Authorization $authorization;
 
     /**
-     * @param Adapter $adapter
-     * @param Cache $cache
-     * @param array<string, array{encode: callable, decode: callable}> $filters
+     * Construct a new Database instance with the given adapter, cache, and optional instance-level filters.
+     *
+     * @param Adapter $adapter The database adapter to use for storage operations.
+     * @param Cache $cache The cache instance for document and collection caching.
+     * @param array<string, array{encode: callable, decode: callable}> $filters Instance-level encode/decode filters.
      */
     public function __construct(
         Adapter $adapter,
@@ -494,69 +328,83 @@ public function __construct(
         $this->instanceFilters = $filters;
 
         $this->setAuthorization(new Authorization());
+        $this->documentTypes[self::METADATA] = Collection::class;
 
         self::addFilter(
             'json',
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
                 $value = ($value instanceof Document) ? $value->getArrayCopy() : $value;
 
-                if (!is_array($value) && !$value instanceof \stdClass) {
+                if (! is_array($value) && ! $value instanceof \stdClass) {
                     return $value;
                 }
 
                 return json_encode($value);
             },
             /**
-             * @param mixed $value
              * @return mixed
+             *
              * @throws Exception
              */
-            function (mixed $value) {
-                if (!is_string($value)) {
+            function (mixed $value, mixed $document = null, mixed $database = null, string $attribute = '') {
+                if (! is_string($value)) {
                     return $value;
                 }
 
-                $value = json_decode($value, true) ?? [];
+                $decoded = json_decode($value, true) ?? [];
+                if (! is_array($decoded)) {
+                    return $decoded;
+                }
+
+                /** @var array<string, mixed> $decoded */
+                if (array_key_exists(Document::ID, $decoded)) {
+                    return new Document($decoded);
+                }
 
-                if (array_key_exists('$id', $value)) {
-                    return new Document($value);
-                } else {
-                    $value = array_map(function ($item) {
-                        if (is_array($item) && array_key_exists('$id', $item)) { // if `$id` exists, create a Document instance
-                            return new Document($item);
-                        }
+                $decoded = array_map(function ($item) use ($document, $attribute) {
+                    if (! is_array($item) || ! array_key_exists(Document::ID, $item)) {
                         return $item;
-                    }, $value);
-                }
+                    }
+                    /** @var array<string, mixed> $item */
+                    if ($document instanceof Collection && $attribute === 'attributes') {
+                        return Attribute::fromArray($item);
+                    }
+                    if ($document instanceof Collection && $attribute === 'indexes') {
+                        return Index::fromArray($item);
+                    }
+
+                    return new Document($item);
+                }, $decoded);
 
-                return $value;
+                return $decoded;
             }
         );
 
         self::addFilter(
             'datetime',
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
                 if (is_null($value)) {
                     return;
                 }
+                if (! is_string($value)) {
+                    return $value;
+                }
                 try {
-                    $value = new \DateTime($value);
-                    $value->setTimezone(new \DateTimeZone(date_default_timezone_get()));
+                    $value = new NativeDateTime($value);
+                    $value->setTimezone(new DateTimeZone(date_default_timezone_get()));
+
                     return DateTime::format($value);
-                } catch (\Throwable) {
+                } catch (Throwable) {
                     return $value;
                 }
             },
             /**
-             * @param string|null $value
              * @return string|null
              */
             function (?string $value) {
@@ -565,141 +413,142 @@ function (?string $value) {
         );
 
         self::addFilter(
-            Database::VAR_POINT,
+            ColumnType::Point->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!is_array($value)) {
+                if (! is_array($value)) {
                     return $value;
                 }
                 try {
-                    return self::encodeSpatialData($value, Database::VAR_POINT);
-                } catch (\Throwable) {
+                    return self::encodeSpatialData($value, ColumnType::Point->value);
+                } catch (Throwable) {
                     return $value;
                 }
             },
             /**
-             * @param string|null $value
              * @return array|null
              */
             function (?string $value) {
                 if ($value === null) {
                     return null;
                 }
-                return $this->adapter->decodePoint($value);
+                if ($this->adapter->hasFeature(Feature\Spatial::class)) {
+                    return $this->adapter->decodePoint($value);
+                }
+
+                return null;
             }
         );
 
         self::addFilter(
-            Database::VAR_LINESTRING,
+            ColumnType::Linestring->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!is_array($value)) {
+                if (! is_array($value)) {
                     return $value;
                 }
                 try {
-                    return self::encodeSpatialData($value, Database::VAR_LINESTRING);
-                } catch (\Throwable) {
+                    return self::encodeSpatialData($value, ColumnType::Linestring->value);
+                } catch (Throwable) {
                     return $value;
                 }
             },
             /**
-             * @param string|null $value
              * @return array|null
              */
             function (?string $value) {
                 if (is_null($value)) {
                     return null;
                 }
-                return $this->adapter->decodeLinestring($value);
+                if ($this->adapter->hasFeature(Feature\Spatial::class)) {
+                    return $this->adapter->decodeLinestring($value);
+                }
+
+                return null;
             }
         );
 
         self::addFilter(
-            Database::VAR_POLYGON,
+            ColumnType::Polygon->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!is_array($value)) {
+                if (! is_array($value)) {
                     return $value;
                 }
                 try {
-                    return self::encodeSpatialData($value, Database::VAR_POLYGON);
-                } catch (\Throwable) {
+                    return self::encodeSpatialData($value, ColumnType::Polygon->value);
+                } catch (Throwable) {
                     return $value;
                 }
             },
             /**
-             * @param string|null $value
              * @return array|null
              */
             function (?string $value) {
                 if (is_null($value)) {
                     return null;
                 }
-                return $this->adapter->decodePolygon($value);
+                if ($this->adapter->hasFeature(Feature\Spatial::class)) {
+                    return $this->adapter->decodePolygon($value);
+                }
+
+                return null;
             }
         );
 
         self::addFilter(
-            Database::VAR_VECTOR,
+            ColumnType::Vector->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!\is_array($value)) {
+                if (! \is_array($value)) {
                     return $value;
                 }
-                if (!\array_is_list($value)) {
+                if (! \array_is_list($value)) {
                     return $value;
                 }
                 foreach ($value as $item) {
-                    if (!\is_int($item) && !\is_float($item)) {
+                    if (! \is_int($item) && ! \is_float($item)) {
                         return $value;
                     }
                 }
 
-                return \json_encode(\array_map(\floatval(...), $value));
+                /** @var array<int|float> $value */
+                return \json_encode(\array_map(fn (int|float $v): float => (float) $v, $value));
             },
             /**
-             * @param string|null $value
-             * @return mixed
+             * @return array|null
              */
             function (?string $value) {
                 if (is_null($value)) {
                     return null;
                 }
-                if (!is_string($value)) {
-                    return $value;
-                }
-                $decoded = json_decode($value, true);
-                return is_array($decoded) ? $decoded : $value;
+                $decoded = self::decodeObject($value);
+
+                return is_array($decoded) || $decoded instanceof \stdClass ? $decoded : $value;
             }
         );
 
         self::addFilter(
-            Database::VAR_OBJECT,
+            ColumnType::Object->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!\is_array($value) && !$value instanceof \stdClass) {
+                if (! \is_array($value) && ! $value instanceof \stdClass) {
                     return $value;
                 }
 
                 return \json_encode($value);
             },
             /**
-             * @param mixed $value
              * @return array|null
              */
             function (mixed $value) {
@@ -707,7 +556,7 @@ function (mixed $value) {
                     return;
                 }
                 // can be non string in case of mongodb as it stores the value as object
-                if (!is_string($value)) {
+                if (! is_string($value)) {
                     return $value;
                 }
                 $decoded = self::decodeObject($value);
@@ -765,419 +614,350 @@ private static function valuesEqual(mixed $value, mixed $old): bool
     }
 
     /**
-     * Add listener to events
-     * Passing a null $callback will remove the listener
+     * Set database to use for current scope
      *
-     * @param string $event
-     * @param string $name
-     * @param ?callable $callback
-     * @return static
+     *
+     * @throws DatabaseException
      */
-    public function on(string $event, string $name, ?callable $callback): static
+    public function setDatabase(string $name): static
     {
-        if (empty($callback)) {
-            unset($this->listeners[$event][$name]);
-            return $this;
-        }
-
-        if (!isset($this->listeners[$event])) {
-            $this->listeners[$event] = [];
-        }
-        $this->listeners[$event][$name] = $callback;
+        $this->adapter->setDatabase($name);
 
         return $this;
     }
 
     /**
-     * Add a transformation to be applied to a query string before an event occurs
+     * Get Database.
+     *
+     * Get Database from current scope
+     *
+     * @throws DatabaseException
+     */
+    public function getDatabase(): string
+    {
+        return $this->adapter->getDatabase();
+    }
+
+    /**
+     * Set Namespace.
+     *
+     * Set namespace to divide different scope of data sets
+     *
      *
-     * @param string $event
-     * @param string $name
-     * @param ?callable $callback
      * @return $this
+     *
+     * @throws DatabaseException
      */
-    public function before(string $event, string $name, ?callable $callback): static
+    public function setNamespace(string $namespace): static
     {
-        $this->adapter->before($event, $name, $callback);
+        $this->adapter->setNamespace($namespace);
 
         return $this;
     }
 
     /**
-     * Silent event generation for calls inside the callback
+     * Get Namespace.
      *
-     * @template T
-     * @param callable(): T $callback
-     * @param array<string>|null $listeners List of listeners to silence; if null, all listeners will be silenced
-     * @return T
+     * Get namespace of current set scope
      */
-    public function silent(callable $callback, ?array $listeners = null): mixed
+    public function getNamespace(): string
     {
-        $previous = $this->silentListeners;
-
-        if (is_null($listeners)) {
-            $this->silentListeners = null;
-        } else {
-            $silentListeners = [];
-            foreach ($listeners as $listener) {
-                $silentListeners[$listener] = true;
-            }
-            $this->silentListeners = $silentListeners;
-        }
-
-        try {
-            return $callback();
-        } finally {
-            $this->silentListeners = $previous;
-        }
+        return $this->adapter->getNamespace();
     }
 
     /**
-     * Get getConnection Id
+     * Get ID Attribute Type.
      *
-     * @return string
-     * @throws Exception
+     * Returns the type of the internal ID attribute (e.g. integer for SQL, uuid7 for MongoDB)
      */
-    public function getConnectionId(): string
+    public function getIdAttributeType(): string
     {
-        return $this->adapter->getConnectionId();
+        return $this->adapter->getIdAttributeType();
     }
 
     /**
-     * Skip relationships for all the calls inside the callback
-     *
-     * @template T
-     * @param callable(): T $callback
-     * @return T
+     * Get Database Adapter
      */
-    public function skipRelationships(callable $callback): mixed
+    public function getAdapter(): Adapter
     {
-        $previous = $this->resolveRelationships;
-        $this->resolveRelationships = false;
+        return $this->adapter;
+    }
 
-        try {
-            return $callback();
-        } finally {
-            $this->resolveRelationships = $previous;
+    /**
+     * Get a utopia-php/query Builder for a collection, pre-configured with
+     * attribute mapping, tenant filtering, and permission hooks.
+     */
+    public function from(string $collection): \Utopia\Query\Builder
+    {
+        if (! $this->adapter->hasFeature(Feature\QueryBuilder::class)) {
+            throw new DatabaseException('Query builder is not supported by this adapter');
         }
+
+        $builder = $this->adapter->getBuilder($collection);
+        $builder->setExecutor(fn (\Utopia\Query\Builder\Statement $statement) => $this->execute($statement));
+
+        return $builder;
     }
 
     /**
-     * Refetch documents after operator updates to get computed values
-     *
-     * @param Document $collection
-     * @param array<Document> $documents
-     * @param array<Query> $selections Select queries from the caller, preserved so the refetch honors the original projection
-     * @return array<Document>
-     * @throws DatabaseException
+     * Get a utopia-php/query Schema builder for DDL operations.
      */
-    protected function refetchDocuments(Document $collection, array $documents, array $selections = []): array
+    public function schema(): \Utopia\Query\Schema
     {
-        if (empty($documents)) {
-            return $documents;
+        if (! $this->adapter->hasFeature(Feature\QueryBuilder::class)) {
+            throw new DatabaseException('Schema builder is not supported by this adapter');
         }
 
-        $sequences = array_map(function ($doc) {
-            $sequence = $doc->getSequence();
-            if ($sequence === null) {
-                throw new DatabaseException('Cannot refetch document without a $sequence: ' . $doc->getId());
-            }
-            return $sequence;
-        }, $documents);
-
-        // Fetch fresh copies with computed operator values, preserving the caller's projection.
-        // Chunk by maxQueryValues (the batch can be up to INSERT_BATCH_SIZE) and bound each find()
-        // to the chunk size, otherwise find()'s default limit would silently drop rows past it.
-        $refetchedMap = [];
-        foreach (\array_chunk($sequences, \max(1, $this->maxQueryValues)) as $chunk) {
-            $refetched = $this->getAuthorization()->skip(fn () => $this->silent(
-                fn () => $this->find(
-                    $collection->getId(),
-                    array_merge([
-                        Query::equal('$sequence', $chunk),
-                        Query::limit(\count($chunk)),
-                    ], $selections)
-                )
-            ));
+        $schema = $this->adapter->getSchema();
+        $schema->setExecutor(fn (\Utopia\Query\Builder\Statement $statement) => $this->execute($statement));
 
-            foreach ($refetched as $doc) {
-                $refetchedMap[$doc->getSequence()] = $doc;
-            }
+        return $schema;
+    }
+
+    /**
+     * @return array<Document>|int
+     */
+    public function execute(\Utopia\Query\Builder|\Utopia\Query\Builder\Statement $query): array|int
+    {
+        if (! $this->adapter->hasFeature(Feature\RawQuery::class)) {
+            throw new DatabaseException('Raw queries are not supported by this adapter');
         }
 
-        $result = [];
-        foreach ($documents as $index => $doc) {
-            $result[$index] = $refetchedMap[$sequences[$index]] ?? $doc;
+        $result = $query instanceof \Utopia\Query\Builder\Statement ? $query : $query->build();
+
+        if ($result->readOnly) {
+            return $this->adapter->rawQuery($result->query, $result->bindings);
         }
 
-        return $result;
+        return $this->adapter->rawMutation($result->query, $result->bindings);
     }
 
-    public function skipRelationshipsExistCheck(callable $callback): mixed
+    public function setTypeRegistry(?TypeRegistry $typeRegistry): static
     {
-        $previous = $this->checkRelationshipsExist;
-        $this->checkRelationshipsExist = false;
+        $this->typeRegistry = $typeRegistry;
 
-        try {
-            return $callback();
-        } finally {
-            $this->checkRelationshipsExist = $previous;
-        }
+        return $this;
     }
 
-    public function skipDuplicates(callable $callback): mixed
+    public function getTypeRegistry(): ?TypeRegistry
     {
-        $previous = $this->skipDuplicates;
-        $this->skipDuplicates = true;
+        return $this->typeRegistry;
+    }
 
-        try {
-            return $callback();
-        } finally {
-            $this->skipDuplicates = $previous;
+    public function setQueryCache(?QueryCache $queryCache): static
+    {
+        $this->lifecycleHooks = \array_values(\array_filter(
+            $this->lifecycleHooks,
+            static fn (Lifecycle $hook): bool => ! $hook instanceof Invalidator,
+        ));
+        $this->queryCacheInvalidator = null;
+        $this->queryCache = $queryCache;
+
+        if ($queryCache !== null) {
+            $this->queryCacheInvalidator = new Invalidator($queryCache);
         }
+
+        return $this;
     }
 
-    /**
-     * Build a tenant-aware identity key for a document.
-     * Returns "<tenant>:<id>" in tenant-per-document shared-table mode, otherwise just the id.
-     */
-    private function tenantKey(Document $document): string
+    public function getQueryCache(): ?QueryCache
     {
-        return ($this->adapter->getSharedTables() && $this->adapter->getTenantPerDocument())
-            ? $document->getTenant() . ':' . $document->getId()
-            : $document->getId();
+        return $this->queryCache;
     }
 
-    /**
-     * Trigger callback for events
-     *
-     * @param string $event
-     * @param mixed $args
-     * @return void
-     */
-    protected function trigger(string $event, mixed $args = null): void
+    public function enableProfiling(): static
     {
-        if (\is_null($this->silentListeners)) {
-            return;
-        }
-        foreach ($this->listeners[self::EVENT_ALL] as $name => $callback) {
-            if (isset($this->silentListeners[$name])) {
-                continue;
-            }
-            $callback($event, $args);
+        if ($this->profiler === null) {
+            $this->profiler = new QueryProfiler();
         }
 
-        foreach (($this->listeners[$event] ?? []) as $name => $callback) {
-            if (isset($this->silentListeners[$name])) {
-                continue;
-            }
-            $callback($event, $args);
+        $this->profiler->enable();
+        $this->adapter->setProfiler($this->profiler);
+
+        return $this;
+    }
+
+    public function disableProfiling(): static
+    {
+        if ($this->profiler !== null) {
+            $this->profiler->disable();
         }
+
+        $this->adapter->setProfiler(null);
+
+        return $this;
+    }
+
+    public function getProfiler(): ?QueryProfiler
+    {
+        return $this->profiler;
     }
 
     /**
-     * Executes $callback with $timestamp set to $requestTimestamp
+     * Get list of keywords that cannot be used
      *
-     * @template T
-     * @param ?\DateTime $requestTimestamp
-     * @param callable(): T $callback
-     * @return T
+     * @return string[]
      */
-    public function withRequestTimestamp(?\DateTime $requestTimestamp, callable $callback): mixed
+    public function getKeywords(): array
     {
-        $previous = $this->timestamp;
-        $this->timestamp = $requestTimestamp;
-        try {
-            $result = $callback();
-        } finally {
-            $this->timestamp = $previous;
-        }
-        return $result;
+        return $this->adapter->getKeywords();
     }
 
     /**
-     * Set Namespace.
-     *
-     * Set namespace to divide different scope of data sets
+     * Set the cache instance
      *
-     * @param string $namespace
      *
      * @return $this
-     *
-     * @throws DatabaseException
      */
-    public function setNamespace(string $namespace): static
+    public function setCache(Cache $cache): static
     {
-        $this->adapter->setNamespace($namespace);
+        $this->cache = $cache;
 
         return $this;
     }
 
     /**
-     * Get Namespace.
-     *
-     * Get namespace of current set scope
-     *
-     * @return string
-     */
-    public function getNamespace(): string
-    {
-        return $this->adapter->getNamespace();
-    }
-
-    /**
-     * Get ID Attribute Type.
-     *
-     * Returns the type of the internal ID attribute (e.g. VAR_INTEGER for SQL, VAR_UUID7 for MongoDB)
-     *
-     * @return string
+     * Get the cache instance
      */
-    public function getIdAttributeType(): string
+    public function getCache(): Cache
     {
-        return $this->adapter->getIdAttributeType();
+        return $this->cache;
     }
 
     /**
-     * Set database to use for current scope
-     *
-     * @param string $name
+     * Set the name to use for cache
      *
-     * @return static
-     * @throws DatabaseException
+     * @return $this
      */
-    public function setDatabase(string $name): static
+    public function setCacheName(string $name): static
     {
-        $this->adapter->setDatabase($name);
+        $this->cacheName = $name;
 
         return $this;
     }
 
     /**
-     * Get Database.
-     *
-     * Get Database from current scope
-     *
-     * @return string
-     * @throws DatabaseException
+     * Get the cache name
      */
-    public function getDatabase(): string
+    public function getCacheName(): string
     {
-        return $this->adapter->getDatabase();
+        return $this->cacheName;
     }
 
     /**
-     * Set the cache instance
-     *
-     * @param Cache $cache
+     * Set shard tables
      *
-     * @return $this
+     * Set whether to share tables between tenants
      */
-    public function setCache(Cache $cache): static
+    public function setSharedTables(bool $sharedTables): static
     {
-        $this->cache = $cache;
+        $this->adapter->setSharedTables($sharedTables);
+
         return $this;
     }
 
     /**
-     * Get the cache instance
+     * Get shared tables
      *
-     * @return Cache
+     * Get whether to share tables between tenants
      */
-    public function getCache(): Cache
+    public function getSharedTables(): bool
     {
-        return $this->cache;
+        return $this->adapter->getSharedTables();
     }
 
     /**
-     * Set the name to use for cache
+     * Set Tenant
      *
-     * @param string $name
-     * @return $this
+     * Set tenant to use if tables are shared
      */
-    public function setCacheName(string $name): static
+    public function setTenant(int|string|null $tenant): static
     {
-        $this->cacheName = $name;
+        $this->adapter->setTenant($tenant);
 
         return $this;
     }
 
     /**
-     * Get the cache name
+     * Get Tenant
      *
-     * @return string
+     * Get tenant to use if tables are shared
      */
-    public function getCacheName(): string
+    public function getTenant(): int|string|null
     {
-        return $this->cacheName;
+        return $this->adapter->getTenant();
     }
 
     /**
-     * Set a metadata value to be printed in the query comments
+     * With Tenant
      *
-     * @param string $key
-     * @param mixed $value
-     * @return static
+     * Execute a callback with a specific tenant
      */
-    public function setMetadata(string $key, mixed $value): static
+    public function withTenant(int|string|null $tenant, callable $callback): mixed
     {
-        $this->adapter->setMetadata($key, $value);
+        $previous = $this->adapter->getTenant();
+        $this->adapter->setTenant($tenant);
+
+        try {
+            return $callback();
+        } finally {
+            $this->adapter->setTenant($previous);
+        }
+    }
+
+    /**
+     * Set whether to allow creating documents with tenant set per document.
+     */
+    public function setTenantPerDocument(bool $enabled): static
+    {
+        $this->adapter->setTenantPerDocument($enabled);
 
         return $this;
     }
 
     /**
-     * Get metadata
-     *
-     * @return array<string, mixed>
+     * Get whether to allow creating documents with tenant set per document.
      */
-    public function getMetadata(): array
+    public function getTenantPerDocument(): bool
     {
-        return $this->adapter->getMetadata();
+        return $this->adapter->getTenantPerDocument();
     }
 
     /**
      * Sets instance of authorization for permission checks
-     *
-     * @param Authorization $authorization
-     * @return self
      */
     public function setAuthorization(Authorization $authorization): self
     {
         $this->adapter->setAuthorization($authorization);
         $this->authorization = $authorization;
+
         return $this;
     }
 
     /**
      * Get Authorization
-     *
-     * @return Authorization
      */
     public function getAuthorization(): Authorization
     {
         return $this->authorization;
     }
 
-    /**
-     * Clear metadata
-     *
-     * @return void
-     */
-    public function resetMetadata(): void
-    {
-        $this->adapter->resetMetadata();
-    }
-
     /**
      * Set maximum query execution time
      *
-     * @param int $milliseconds
-     * @param string $event
-     * @return static
      * @throws Exception
      */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): static
+    public function setTimeout(int $milliseconds, Event $event = Event::All): static
     {
+        // Not hasFeature(): on a pool that is a delegated call, so guarding
+        // with it dials the database just to configure a handle. A pool holds
+        // the timeout without checking out and defers the backing adapter's
+        // refusal to the moment it is applied, which is why the method's
+        // presence -- not the feature interface -- is what is asked here.
+        if (! \method_exists($this->adapter, 'setTimeout')) {
+            throw new DatabaseException('Adapter does not support timeouts');
+        }
+
         $this->adapter->setTimeout($milliseconds, $event);
 
         return $this;
@@ -1185,261 +965,248 @@ public function setTimeout(int $milliseconds, string $event = Database::EVENT_AL
 
     /**
      * Clear maximum query execution time
-     *
-     * @param string $event
-     * @return void
      */
-    public function clearTimeout(string $event = Database::EVENT_ALL): void
+    public function clearTimeout(Event $event = Event::All): void
     {
+        if (! \method_exists($this->adapter, 'clearTimeout')) {
+            throw new DatabaseException('Adapter does not support timeouts');
+        }
+
         $this->adapter->clearTimeout($event);
     }
 
     /**
-     * Enable filters
+     * Get the current relationship hook.
      *
-     * @return $this
+     * @return Relationships|null The relationship hook, or null if not set.
      */
-    public function enableFilters(): static
+    public function getRelationshipHook(): ?Relationships
     {
-        $this->filter = true;
-        return $this;
+        return $this->relationshipHook;
     }
 
     /**
-     * Disable filters
+     * Set whether to preserve original date values instead of overwriting with current timestamps.
      *
+     * @param bool $preserve True to preserve dates on write operations.
      * @return $this
      */
-    public function disableFilters(): static
+    public function setPreserveDates(bool $preserve): static
     {
-        $this->filter = false;
+        $this->preserveDates = $preserve;
+
         return $this;
     }
 
+    public function getDropUnknownAttributes(): bool
+    {
+        return $this->dropUnknownAttributes;
+    }
+
     /**
-     * Skip filters
-     *
-     * Execute a callback without filters
+     * Drop attributes missing from the collection schema instead of rejecting the write.
      *
-     * @template T
-     * @param callable(): T $callback
-     * @param array<string>|null $filters
-     * @return T
+     * Enable this where the schema is owned by the application rather than the caller, so a
+     * deploy that writes an attribute before its migration has run degrades to a warning
+     * instead of failing every write.
      */
-    public function skipFilters(callable $callback, ?array $filters = null): mixed
+    public function setDropUnknownAttributes(bool $drop): static
     {
-        if (empty($filters)) {
-            $initial = $this->filter;
-            $this->disableFilters();
+        $this->dropUnknownAttributes = $drop;
 
-            try {
-                return $callback();
-            } finally {
-                $this->filter = $initial;
-            }
-        }
+        return $this;
+    }
 
-        $previous = $this->filter;
-        $previousDisabled = $this->disabledFilters;
-        $disabled = [];
-        foreach ($filters as $name) {
-            $disabled[$name] = true;
-        }
-        $this->disabledFilters = $disabled;
+    /**
+     * Get whether date preservation is enabled.
+     *
+     * @return bool True if dates are being preserved.
+     */
+    public function getPreserveDates(): bool
+    {
+        return $this->preserveDates;
+    }
+
+    /**
+     * Execute a callback with date preservation enabled, restoring the previous state afterward.
+     *
+     * @param callable $callback The callback to execute.
+     * @return mixed The callback's return value.
+     */
+    public function withPreserveDates(callable $callback): mixed
+    {
+        $previous = $this->preserveDates;
+        $this->preserveDates = true;
 
         try {
             return $callback();
         } finally {
-            $this->filter = $previous;
-            $this->disabledFilters = $previousDisabled;
+            $this->preserveDates = $previous;
         }
     }
 
     /**
-     * Get instance filters
+     * Execute a callback with skipDuplicates enabled, restoring the previous state afterward.
      *
-     * @return array<string, array{encode: callable, decode: callable, signature: string}>
+     * @template T
+     * @param callable(): T $callback
+     * @return T
      */
-    public function getInstanceFilters(): array
+    public function skipDuplicates(callable $callback): mixed
     {
-        return $this->instanceFilters;
+        $previous = $this->skipDuplicates;
+        $this->skipDuplicates = true;
+
+        try {
+            return $callback();
+        } finally {
+            $this->skipDuplicates = $previous;
+        }
     }
 
     /**
-     * Enable validation
+     * Set whether to preserve original sequence values instead of auto-generating them.
      *
+     * @param bool $preserve True to preserve sequence values on write operations.
      * @return $this
      */
-    public function enableValidation(): static
+    public function setPreserveSequence(bool $preserve): static
     {
-        $this->validate = true;
+        $this->preserveSequence = $preserve;
 
         return $this;
     }
 
     /**
-     * Disable validation
+     * Get whether sequence preservation is enabled.
      *
-     * @return $this
+     * @return bool True if sequence values are being preserved.
      */
-    public function disableValidation(): static
+    public function getPreserveSequence(): bool
     {
-        $this->validate = false;
-
-        return $this;
+        return $this->preserveSequence;
     }
 
     /**
-     * Skip Validation
-     *
-     * Execute a callback without validation
+     * Execute a callback with sequence preservation enabled, restoring the previous state afterward.
      *
-     * @template T
-     * @param callable(): T $callback
-     * @return T
+     * @param callable $callback The callback to execute.
+     * @return mixed The callback's return value.
      */
-    public function skipValidation(callable $callback): mixed
+    public function withPreserveSequence(callable $callback): mixed
     {
-        $initial = $this->validate;
-        $this->disableValidation();
+        $previous = $this->preserveSequence;
+        $this->preserveSequence = true;
 
         try {
             return $callback();
         } finally {
-            $this->validate = $initial;
+            $this->preserveSequence = $previous;
         }
     }
 
     /**
-     * Get shared tables
+     * Set the migration mode flag, which relaxes certain constraints during data migrations.
      *
-     * Get whether to share tables between tenants
-     * @return bool
+     * @param bool $migrating True to enable migration mode.
+     * @return $this
      */
-    public function getSharedTables(): bool
+    public function setMigrating(bool $migrating): self
     {
-        return $this->adapter->getSharedTables();
+        $this->migrating = $migrating;
+
+        return $this;
     }
 
     /**
-     * Set shard tables
-     *
-     * Set whether to share tables between tenants
+     * Check whether the database is currently in migration mode.
      *
-     * @param bool $sharedTables
-     * @return static
+     * @return bool True if migration mode is active.
      */
-    public function setSharedTables(bool $sharedTables): static
+    public function isMigrating(): bool
     {
-        $this->adapter->setSharedTables($sharedTables);
-
-        return $this;
+        return $this->migrating;
     }
 
     /**
-     * Set Tenant
+     * Set the maximum number of values allowed in a single query (e.g., IN clauses).
      *
-     * Set tenant to use if tables are shared
-     *
-     * @param int|string|null $tenant
-     * @return static
+     * @param int $max The maximum number of query values.
+     * @return $this
      */
-    public function setTenant(int|string|null $tenant): static
+    public function setMaxQueryValues(int $max): self
     {
-        $this->adapter->setTenant($tenant);
+        if ($this->maxQueryValues !== $max) {
+            // Validator cache key encodes maxQueryValues; entries built under
+            // the previous limit must be discarded so subsequent validation
+            // honors the new ceiling.
+            $this->documentsValidatorCache = [];
+        }
+
+        $this->maxQueryValues = $max;
 
         return $this;
     }
 
     /**
-     * Get Tenant
-     *
-     * Get tenant to use if tables are shared
+     * Get the maximum number of values allowed in a single query.
      *
-     * @return int|string|null
+     * @return int The current maximum query values limit.
      */
-    public function getTenant(): int|string|null
+    public function getMaxQueryValues(): int
     {
-        return $this->adapter->getTenant();
+        return $this->maxQueryValues;
     }
 
     /**
-     * With Tenant
-     *
-     * Execute a callback with a specific tenant
+     * Set list of collections which are globally accessible
      *
-     * @param int|string|null $tenant
-     * @param callable $callback
-     * @return mixed
+     * @param  array<string>  $collections
+     * @return $this
      */
-    public function withTenant(int|string|null $tenant, callable $callback): mixed
+    public function setGlobalCollections(array $collections): static
     {
-        $previous = $this->adapter->getTenant();
-        $this->adapter->setTenant($tenant);
-
-        try {
-            return $callback();
-        } finally {
-            $this->adapter->setTenant($previous);
+        foreach ($collections as $collection) {
+            $this->globalCollections[$collection] = true;
         }
-    }
-
-    /**
-     * Set whether to allow creating documents with tenant set per document.
-     *
-     * @param bool $enabled
-     * @return static
-     */
-    public function setTenantPerDocument(bool $enabled): static
-    {
-        $this->adapter->setTenantPerDocument($enabled);
 
         return $this;
     }
 
     /**
-     * Get whether to allow creating documents with tenant set per document.
+     * Get list of collections which are globally accessible
      *
-     * @return bool
+     * @return array<string>
      */
-    public function getTenantPerDocument(): bool
+    public function getGlobalCollections(): array
     {
-        return $this->adapter->getTenantPerDocument();
+        return \array_keys($this->globalCollections);
     }
 
     /**
-     * Enable or disable LOCK=SHARED during ALTER TABLE operation
-     *
-     * Set lock mode when altering tables
-     *
-     * @param bool $enabled
-     * @return static
+     * Clear global collections
      */
-    public function enableLocks(bool $enabled): static
+    public function resetGlobalCollections(): void
     {
-        if ($this->adapter->getSupportForAlterLocks()) {
-            $this->adapter->enableAlterLocks($enabled);
-        }
-
-        return $this;
+        $this->globalCollections = [];
     }
 
     /**
      * Set custom document class for a collection
      *
-     * @param string $collection Collection ID
-     * @param class-string<Document> $className Fully qualified class name that extends Document
-     * @return static
+     * @param  string  $collection  Collection ID
+     * @param  string  $className  Fully qualified class name that extends Document
+     *
      * @throws DatabaseException
      */
     public function setDocumentType(string $collection, string $className): static
     {
-        if (!\class_exists($className)) {
+        if (! \class_exists($className)) {
             throw new DatabaseException("Class {$className} does not exist");
         }
 
-        if (!\is_subclass_of($className, Document::class)) {
-            throw new DatabaseException("Class {$className} must extend " . Document::class);
+        if (! \is_subclass_of($className, Document::class)) {
+            throw new DatabaseException("Class {$className} must extend ".Document::class);
         }
 
         $this->documentTypes[$collection] = $className;
@@ -1450,7 +1217,7 @@ public function setDocumentType(string $collection, string $className): static
     /**
      * Get custom document class for a collection
      *
-     * @param string $collection Collection ID
+     * @param  string  $collection  Collection ID
      * @return class-string<Document>|null
      */
     public function getDocumentType(string $collection): ?string
@@ -1461,8 +1228,7 @@ public function getDocumentType(string $collection): ?string
     /**
      * Clear document type mapping for a collection
      *
-     * @param string $collection Collection ID
-     * @return static
+     * @param  string  $collection  Collection ID
      */
     public function clearDocumentType(string $collection): static
     {
@@ -1473,7878 +1239,368 @@ public function clearDocumentType(string $collection): static
 
     /**
      * Clear all document type mappings
-     *
-     * @return static
      */
     public function clearAllDocumentTypes(): static
     {
-        $this->documentTypes = [];
+        $this->documentTypes = [self::METADATA => Collection::class];
 
         return $this;
     }
 
     /**
-     * Create a document instance of the appropriate type
+     * Enable or disable LOCK=SHARED during ALTER TABLE operation
      *
-     * @param string $collection Collection ID
-     * @param array<string, mixed> $data Document data
-     * @return Document
+     * Set lock mode when altering tables
      */
-    protected function createDocumentInstance(string $collection, array $data): Document
+    public function enableLocks(bool $enabled): static
     {
-        $className = $this->documentTypes[$collection] ?? Document::class;
-
-        return new $className($data);
-    }
+        if ($this->adapter->supports(Capability::AlterLock)) {
+            $this->adapter->enableAlterLocks($enabled);
+        }
 
-    public function getDropUnknownAttributes(): bool
-    {
-        return $this->dropUnknownAttributes;
+        return $this;
     }
 
     /**
-     * Drop attributes missing from the collection schema instead of rejecting the write.
+     * Enable validation
      *
-     * Enable this where the schema is owned by the application rather than the caller, so a
-     * deploy that writes an attribute before its migration has run degrades to a warning
-     * instead of failing every write.
+     * @return $this
      */
-    public function setDropUnknownAttributes(bool $drop): static
-    {
-        $this->dropUnknownAttributes = $drop;
-
-        return $this;
-    }
-
-    public function getPreserveDates(): bool
-    {
-        return $this->preserveDates;
-    }
-
-    public function setPreserveDates(bool $preserve): static
+    public function enableValidation(): static
     {
-        $this->preserveDates = $preserve;
+        $this->validate = true;
 
         return $this;
     }
 
-    public function setMigrating(bool $migrating): self
+    /**
+     * Disable validation
+     *
+     * @return $this
+     */
+    public function disableValidation(): static
     {
-        $this->migrating = $migrating;
+        $this->validate = false;
 
         return $this;
     }
 
-    public function isMigrating(): bool
+    /**
+     * Whether document structure validation is currently enabled.
+     */
+    public function isValidationEnabled(): bool
     {
-        return $this->migrating;
+        return $this->validate;
     }
 
-    public function withPreserveDates(callable $callback): mixed
+    /**
+     * Skip Validation
+     *
+     * Execute a callback without validation
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     */
+    public function skipValidation(callable $callback): mixed
     {
-        $previous = $this->preserveDates;
-        $this->preserveDates = true;
+        $initial = $this->validate;
+        $this->validate = false;
 
         try {
             return $callback();
         } finally {
-            $this->preserveDates = $previous;
+            $this->validate = $initial;
         }
     }
 
-    public function getPreserveSequence(): bool
-    {
-        return $this->preserveSequence;
-    }
-
-    public function setPreserveSequence(bool $preserve): static
+    /**
+     * Register a hook into the database pipeline.
+     *
+     * Dispatches by type:
+     * - {@see Hook\Lifecycle} — fire-and-forget side effects (auditing, logging)
+     * - {@see Hook\Decorator} — document transformation on read/write results
+     * - {@see Hook\Relationships} — relationship resolution and mutation
+     * - {@see Hook\Write} — row-level write interception (permissions, tenant)
+     * - {@see Hook\Transform} — raw SQL transformation before execution
+     */
+    public function addHook(\Utopia\Query\Hook $hook): static
     {
-        $this->preserveSequence = $preserve;
+        if ($hook instanceof Lifecycle) {
+            if ($hook instanceof Invalidator) {
+                $this->lifecycleHooks = \array_values(\array_filter(
+                    $this->lifecycleHooks,
+                    static fn (Lifecycle $registered): bool => ! $registered instanceof Invalidator,
+                ));
+                $this->queryCacheInvalidator = $hook;
+            } else {
+                $this->lifecycleHooks[] = $hook;
+            }
+        }
 
-        return $this;
-    }
+        if ($hook instanceof Hook\Decorator) {
+            $this->decorators[] = $hook;
+        }
 
-    public function withPreserveSequence(callable $callback): mixed
-    {
-        $previous = $this->preserveSequence;
-        $this->preserveSequence = true;
+        if ($hook instanceof Relationships) {
+            $this->relationshipHook = $hook;
+        }
 
-        try {
-            return $callback();
-        } finally {
-            $this->preserveSequence = $previous;
+        if ($hook instanceof Hook\Write) {
+            $this->adapter->addWriteHook($hook);
         }
-    }
 
-    public function setMaxQueryValues(int $max): self
-    {
-        $this->maxQueryValues = $max;
+        if ($hook instanceof Transform) {
+            $this->adapter->addTransform($hook::class, $hook);
+        }
 
         return $this;
     }
 
-    public function getMaxQueryValues(): int
-    {
-        return $this->maxQueryValues;
-    }
-
     /**
-     * Set list of collections which are globally accessible
-     *
-     * @param array<string> $collections
-     * @return $this
+     * Apply all registered decorators to a single document.
      */
-    public function setGlobalCollections(array $collections): static
+    protected function decorateDocument(Event $event, Document $collection, Document $document): Document
     {
-        foreach ($collections as $collection) {
-            $this->globalCollections[$collection] = true;
+        if ($this->areEventsSilenced()) {
+            return $document;
         }
 
-        return $this;
-    }
+        foreach ($this->decorators as $decorator) {
+            $document = $decorator->decorate($event, $collection, $document);
+        }
 
-    /**
-     * Get list of collections which are globally accessible
-     *
-     * @return array<string>
-     */
-    public function getGlobalCollections(): array
-    {
-        return \array_keys($this->globalCollections);
+        return $document;
     }
 
     /**
-     * Clear global collections
+     * Apply all registered document decorators to an array of documents.
      *
-     * @return void
+     * @param  array<Document>  $documents
+     * @return array<Document>
      */
-    public function resetGlobalCollections(): void
+    protected function decorateDocuments(Event $event, Document $collection, array $documents): array
     {
-        $this->globalCollections = [];
-    }
+        if (empty($this->decorators)) {
+            return $documents;
+        }
 
-    /**
-     * Get list of keywords that cannot be used
-     *
-     * @return string[]
-     */
-    public function getKeywords(): array
-    {
-        return $this->adapter->getKeywords();
+        foreach ($documents as $i => $document) {
+            $documents[$i] = $this->decorateDocument($event, $collection, $document);
+        }
+
+        return $documents;
     }
 
+
     /**
-     * Get Database Adapter
-     *
-     * @return Adapter
+     * Remove a query transform hook from the adapter.
      */
-    public function getAdapter(): Adapter
+    public function removeTransform(string $name): static
     {
-        return $this->adapter;
+        $this->adapter->removeTransform($name);
+
+        return $this;
     }
 
     /**
-     * Run a callback inside a transaction.
+     * Silence lifecycle hooks for calls inside the callback.
      *
      * @template T
-     * @param callable(): T $callback
+     *
+     * @param  callable(): T  $callback
      * @return T
-     * @throws \Throwable
      */
-    public function withTransaction(callable $callback): mixed
+    public function silent(callable $callback): mixed
     {
-        return $this->adapter->withTransaction($callback);
+        $context = $this->getEventContext();
+        $this->silencedEvents[$context] = ($this->silencedEvents[$context] ?? 0) + 1;
+
+        try {
+            return $callback();
+        } finally {
+            $depth = $this->silencedEvents[$context] - 1;
+            if ($depth === 0) {
+                unset($this->silencedEvents[$context]);
+            } else {
+                $this->silencedEvents[$context] = $depth;
+            }
+        }
     }
 
-    /**
-     * Ping Database
-     *
-     * @return bool
-     */
-    public function ping(): bool
+    protected function areEventsSilenced(): bool
     {
-        return $this->adapter->ping();
+        return ($this->silencedEvents[$this->getEventContext()] ?? 0) > 0;
     }
 
-    public function reconnect(): void
+    private function getEventContext(): int
     {
-        $this->adapter->reconnect();
+        $context = Coroutine::getCid();
+
+        return \is_int($context) ? $context : -1;
     }
 
     /**
-     * Create the database
+     * Register a global attribute filter with encode and decode callbacks for data transformation.
      *
-     * @param string|null $database
-     * @return bool
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws Exception
+     * @param string $name The unique filter name.
+     * @param callable $encode Callback to transform the value before storage.
+     * @param callable $decode Callback to transform the value after retrieval.
      */
-    public function create(?string $database = null): bool
+    public static function addFilter(string $name, callable $encode, callable $decode): void
     {
-        $database ??= $this->adapter->getDatabase();
-
-        $this->adapter->create($database);
-
-        /**
-         * Create array of attribute documents
-         * @var array<Document> $attributes
-         */
-        $attributes = \array_map(function ($attribute) {
-            return new Document($attribute);
-        }, self::COLLECTION['attributes']);
+        self::$filters[$name] = [
+            'encode' => $encode,
+            'decode' => $decode,
+            'signature' => self::computeCallableSignature($encode) . ':' . self::computeCallableSignature($decode),
+        ];
+    }
 
-        $this->silent(fn () => $this->createCollection(self::METADATA, $attributes));
+    private static function computeCallableSignature(callable $callable): string
+    {
+        if (\is_string($callable)) {
+            return $callable;
+        }
 
-        try {
-            $this->trigger(self::EVENT_DATABASE_CREATE, $database);
-        } catch (\Throwable $e) {
-            // Ignore
+        if (\is_array($callable)) {
+            $class = \is_object($callable[0]) ? \get_class($callable[0]) : $callable[0];
+            return $class . '::' . $callable[1];
         }
 
-        return true;
+        $closure = \Closure::fromCallable($callable);
+        $ref = new \ReflectionFunction($closure);
+        return ($ref->getFileName() ?: 'unknown') . ':' . $ref->getStartLine();
     }
 
     /**
-     * Check if database exists
-     * Optionally check if collection exists in database
-     *
-     * @param string|null $database (optional) database name
-     * @param string|null $collection (optional) collection name
+     * Enable filters
      *
-     * @return bool
+     * @return $this
      */
-    public function exists(?string $database = null, ?string $collection = null): bool
+    public function enableFilters(): static
     {
-        $database ??= $this->adapter->getDatabase();
+        $this->filter = true;
 
-        return $this->adapter->exists($database, $collection);
+        return $this;
     }
 
     /**
-     * List Databases
+     * Disable filters
      *
-     * @return array<Document>
+     * @return $this
      */
-    public function list(): array
+    public function disableFilters(): static
     {
-        $databases = $this->adapter->list();
-
-        try {
-            $this->trigger(self::EVENT_DATABASE_LIST, $databases);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
+        $this->filter = false;
 
-        return $databases;
+        return $this;
     }
 
     /**
-     * Delete Database
+     * Skip filters
      *
-     * @param string|null $database
-     * @return bool
-     * @throws DatabaseException
+     * Execute a callback without filters
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @param  array<string>|null  $filters
+     * @return T
      */
-    public function delete(?string $database = null): bool
+    public function skipFilters(callable $callback, ?array $filters = null): mixed
     {
-        $database = $database ?? $this->adapter->getDatabase();
-
-        $deleted = $this->adapter->delete($database);
-
-        try {
-            $this->trigger(self::EVENT_DATABASE_DELETE, [
-                'name' => $database,
-                'deleted' => $deleted
-            ]);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        $this->cache->flush();
-
-        return $deleted;
-    }
-
-    /**
-     * Create Collection
-     *
-     * @param string $id
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @param array<string>|null $permissions
-     * @param bool $documentSecurity
-     * @return Document
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws LimitException
-     */
-    public function createCollection(string $id, array $attributes = [], array $indexes = [], ?array $permissions = null, bool $documentSecurity = true): Document
-    {
-        foreach ($attributes as &$attribute) {
-            if (in_array($attribute['type'], self::ATTRIBUTE_FILTER_TYPES)) {
-                $existingFilters = $attribute['filters'] ?? [];
-                if (!is_array($existingFilters)) {
-                    $existingFilters = [$existingFilters];
-                }
-                $attribute['filters'] = array_values(
-                    array_unique(array_merge($existingFilters, [$attribute['type']]))
-                );
-            }
-        }
-        unset($attribute);
-
-        $permissions ??= [
-            Permission::create(Role::any()),
-        ];
-
-        if ($this->validate) {
-            $validator = new Permissions();
-            if (!$validator->isValid($permissions)) {
-                throw new DatabaseException($validator->getDescription());
-            }
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($id));
-
-        if (!$collection->isEmpty() && $id !== self::METADATA) {
-            throw new DuplicateException('Collection ' . $id . ' already exists');
-        }
-
-        // Enforce single TTL index per collection
-        if ($this->validate && $this->getAdapter()->getSupportForTTLIndexes()) {
-            $ttlIndexes = array_filter($indexes, fn (Document $idx) => $idx->getAttribute('type') === self::INDEX_TTL);
-            if (count($ttlIndexes) > 1) {
-                throw new IndexException('There can be only one TTL index in a collection');
-            }
-        }
-
-        /**
-         * Fix metadata index length & orders
-         */
-        foreach ($indexes as $key => $index) {
-            $lengths = $index->getAttribute('lengths', []);
-            $orders = $index->getAttribute('orders', []);
-
-            foreach ($index->getAttribute('attributes', []) as $i => $attr) {
-                foreach ($attributes as $collectionAttribute) {
-                    if ($collectionAttribute->getAttribute('$id') === $attr) {
-                        /**
-                         * mysql does not save length in collection when length = attributes size
-                         */
-                        if (in_array($collectionAttribute->getAttribute('type'), self::STRING_TYPES)) {
-                            if (!empty($lengths[$i]) && $lengths[$i] === $collectionAttribute->getAttribute('size') && $this->adapter->getMaxIndexLength() > 0) {
-                                $lengths[$i] = null;
-                            }
-                        }
-
-                        $isArray = $collectionAttribute->getAttribute('array', false);
-                        if ($isArray) {
-                            if ($this->adapter->getMaxIndexLength() > 0) {
-                                $lengths[$i] = self::MAX_ARRAY_INDEX_LENGTH;
-                            }
-                            $orders[$i] = null;
-                        }
-                        break;
-                    }
-                }
-            }
-
-            $index->setAttribute('lengths', $lengths);
-            $index->setAttribute('orders', $orders);
-            $indexes[$key] = $index;
-        }
-
-        $collection = new Document([
-            '$id' => ID::custom($id),
-            '$permissions' => $permissions,
-            'name' => $id,
-            'attributes' => $attributes,
-            'indexes' => $indexes,
-            'documentSecurity' => $documentSecurity
-        ]);
-
-        if ($this->validate) {
-            $validator = new IndexValidator(
-                $attributes,
-                [],
-                $this->adapter->getMaxIndexLength(),
-                $this->adapter->getInternalIndexesKeys(),
-                $this->adapter->getSupportForIndexArray(),
-                $this->adapter->getSupportForSpatialIndexNull(),
-                $this->adapter->getSupportForSpatialIndexOrder(),
-                $this->adapter->getSupportForVectors(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForMultipleFulltextIndexes(),
-                $this->adapter->getSupportForIdenticalIndexes(),
-                $this->adapter->getSupportForObjectIndexes(),
-                $this->adapter->getSupportForTrigramIndex(),
-                $this->adapter->getSupportForSpatialAttributes(),
-                $this->adapter->getSupportForIndex(),
-                $this->adapter->getSupportForUniqueIndex(),
-                $this->adapter->getSupportForFulltextIndex(),
-                $this->adapter->getSupportForTTLIndexes(),
-                $this->adapter->getSupportForObject()
-            );
-            foreach ($indexes as $index) {
-                if (!$validator->isValid($index)) {
-                    throw new IndexException($validator->getDescription());
-                }
-            }
-        }
-
-        // Check index limits, if given
-        if ($indexes && $this->adapter->getCountOfIndexes($collection) > $this->adapter->getLimitForIndexes()) {
-            throw new LimitException('Index limit of ' . $this->adapter->getLimitForIndexes() . ' exceeded. Cannot create collection.');
-        }
-
-        // Check attribute limits, if given
-        if ($attributes) {
-            if (
-                $this->adapter->getLimitForAttributes() > 0 &&
-                $this->adapter->getCountOfAttributes($collection) > $this->adapter->getLimitForAttributes()
-            ) {
-                throw new LimitException('Attribute limit of ' . $this->adapter->getLimitForAttributes() . ' exceeded. Cannot create collection.');
-            }
-
-            if (
-                $this->adapter->getDocumentSizeLimit() > 0 &&
-                $this->adapter->getAttributeWidth($collection) > $this->adapter->getDocumentSizeLimit()
-            ) {
-                throw new LimitException('Document size limit of ' . $this->adapter->getDocumentSizeLimit() . ' exceeded. Cannot create collection.');
-            }
-        }
-
-        $createdPhysicalTable = false;
-
-        try {
-            $this->adapter->createCollection($id, $attributes, $indexes);
-            $createdPhysicalTable = true;
-        } catch (DuplicateException $e) {
-            if ($id === self::METADATA
-                || ($this->adapter->getSharedTables()
-                    && $this->adapter->exists($this->adapter->getDatabase(), $id))) {
-                // The metadata table must never be dropped during reconciliation.
-                // In shared-tables mode the physical table is reused across
-                // tenants. A DuplicateException simply means the table already
-                // exists for another tenant — not an orphan.
-            } else {
-                // The table exists and this process did not create it. It may
-                // belong to a peer that has not committed metadata yet, or it
-                // may be an orphan. Dropping it destroyed live collections
-                // during concurrent boot; attaching this caller's metadata to
-                // an unknown physical schema can invent columns that are not
-                // there. Leave the table and report Duplicate. Claiming the
-                // metadata row first is #939.
-                try {
-                    $this->purgeCachedDocument(self::METADATA, $id);
-                } catch (\Throwable $cacheError) {
-                    Console::warning('Warning: Failed to purge stale collection cache: ' . $cacheError->getMessage());
-                }
-                throw new DuplicateException('Collection ' . $id . ' already exists', previous: $e);
-            }
-        }
-
-        if ($id === self::METADATA) {
-            return new Document(self::COLLECTION);
-        }
-
-        try {
-            $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
-        } catch (DuplicateException $e) {
-            // A concurrent creator committed the metadata for this id first, so
-            // the physical table is the one its metadata describes. Rolling back
-            // here would drop a live collection out from under it.
-            try {
-                $this->purgeCachedDocument(self::METADATA, $id);
-            } catch (\Throwable $cacheError) {
-                Console::warning('Warning: Failed to purge stale collection cache: ' . $cacheError->getMessage());
-            }
-            throw new DuplicateException('Collection ' . $id . ' already exists', previous: $e);
-        } catch (\Throwable $e) {
-            if ($createdPhysicalTable) {
-                try {
-                    $this->cleanupCollection($id);
-                } catch (\Throwable $e) {
-                    Console::error("Failed to rollback collection '{$id}': " . $e->getMessage());
-                }
-            }
-            throw new DatabaseException("Failed to create collection metadata for '{$id}': " . $e->getMessage(), previous: $e);
-        }
-
-        try {
-            $this->trigger(self::EVENT_COLLECTION_CREATE, $createdCollection);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $createdCollection;
-    }
-
-    /**
-     * Update Collections Permissions.
-     *
-     * @param string $id
-     * @param array<string> $permissions
-     * @param bool $documentSecurity
-     *
-     * @return Document
-     * @throws ConflictException
-     * @throws DatabaseException
-     */
-    public function updateCollection(string $id, array $permissions, bool $documentSecurity): Document
-    {
-        if ($this->validate) {
-            $validator = new Permissions();
-            if (!$validator->isValid($permissions)) {
-                throw new DatabaseException($validator->getDescription());
-            }
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($id));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if (
-            $this->adapter->getSharedTables()
-            && $collection->getTenant() != $this->adapter->getTenant()
-        ) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $collection
-            ->setAttribute('$permissions', $permissions)
-            ->setAttribute('documentSecurity', $documentSecurity);
-
-        $collection = $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection));
-
-        try {
-            $this->trigger(self::EVENT_COLLECTION_UPDATE, $collection);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $collection;
-    }
-
-    /**
-     * Get Collection
-     *
-     * @param string $id
-     *
-     * @return Document
-     * @throws DatabaseException
-     */
-    public function getCollection(string $id): Document
-    {
-        $collection = $this->silent(fn () => $this->getDocument(self::METADATA, $id));
-
-        if (
-            $id !== self::METADATA
-            && $this->adapter->getSharedTables()
-            && $collection->getTenant() !== null
-            && $collection->getTenant() != $this->adapter->getTenant()
-        ) {
-            return new Document();
-        }
-
-        try {
-            $this->trigger(self::EVENT_COLLECTION_READ, $collection);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $collection;
-    }
-
-    /**
-     * List Collections
-     *
-     * @param int $offset
-     * @param int $limit
-     *
-     * @return array<Document>
-     * @throws Exception
-     */
-    public function listCollections(int $limit = 25, int $offset = 0): array
-    {
-        $result = $this->silent(fn () => $this->find(self::METADATA, [
-            Query::limit($limit),
-            Query::offset($offset)
-        ]));
-
-        try {
-            $this->trigger(self::EVENT_COLLECTION_LIST, $result);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $result;
-    }
-
-    /**
-     * Get Collection Size
-     *
-     * @param string $collection
-     *
-     * @return int
-     * @throws Exception
-     */
-    public function getSizeOfCollection(string $collection): int
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if ($this->adapter->getSharedTables() && $collection->getTenant() != $this->adapter->getTenant()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        return $this->adapter->getSizeOfCollection($collection->getId());
-    }
-
-    /**
-     * Get Collection Size on disk
-     *
-     * @param string $collection
-     *
-     * @return int
-     */
-    public function getSizeOfCollectionOnDisk(string $collection): int
-    {
-        if ($this->adapter->getSharedTables() && empty($this->adapter->getTenant())) {
-            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if ($this->adapter->getSharedTables() && $collection->getTenant() != $this->adapter->getTenant()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        return $this->adapter->getSizeOfCollectionOnDisk($collection->getId());
-    }
-
-    /**
-     * Analyze a collection updating its metadata on the database engine
-     *
-     * @param string $collection
-     * @return bool
-     */
-    public function analyzeCollection(string $collection): bool
-    {
-        return $this->adapter->analyzeCollection($collection);
-    }
-
-    /**
-     * Delete Collection
-     *
-     * @param string $id
-     *
-     * @return bool
-     * @throws DatabaseException
-     */
-    public function deleteCollection(string $id): bool
-    {
-        $collection = $this->silent(fn () => $this->getDocument(self::METADATA, $id));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if ($this->adapter->getSharedTables() && $collection->getTenant() != $this->adapter->getTenant()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes'),
-            fn ($attribute) => $attribute->getAttribute('type') === Database::VAR_RELATIONSHIP
-        );
-
-        foreach ($relationships as $relationship) {
-            $this->deleteRelationship($collection->getId(), $relationship->getId());
-        }
-
-        // Re-fetch collection to get current state after relationship deletions
-        $currentCollection = $this->silent(fn () => $this->getDocument(self::METADATA, $id));
-        $currentAttributes = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('attributes', []);
-        $currentIndexes = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('indexes', []);
-
-        $schemaDeleted = false;
-        try {
-            $this->adapter->deleteCollection($id);
-            $schemaDeleted = true;
-        } catch (NotFoundException) {
-            // Ignore — collection already absent from schema
-        }
-
-        if ($id === self::METADATA) {
-            $deleted = true;
-        } else {
-            try {
-                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
-            } catch (\Throwable $e) {
-                if ($schemaDeleted) {
-                    try {
-                        $this->adapter->createCollection($id, $currentAttributes, $currentIndexes);
-                    } catch (\Throwable) {
-                        // Silent rollback — best effort to restore consistency
-                    }
-                }
-                throw new DatabaseException(
-                    "Failed to persist metadata for collection deletion '{$id}': " . $e->getMessage(),
-                    previous: $e
-                );
-            }
-        }
-
-        if ($deleted) {
-            try {
-                $this->trigger(self::EVENT_COLLECTION_DELETE, $collection);
-            } catch (\Throwable $e) {
-                // Ignore
-            }
-        }
-
-        $this->purgeCachedCollection($id);
-
-        return $deleted;
-    }
-
-    /**
-     * Create Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size utf8mb4 chars length
-     * @param bool $required
-     * @param mixed $default
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $format optional validation format of attribute
-     * @param array<string, mixed> $formatOptions assoc array with custom options that can be passed for the format validation
-     * @param array<string> $filters
-     *
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws StructureException
-     * @throws Exception
-     */
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $required, mixed $default = null, bool $signed = true, bool $array = false, ?string $format = null, array $formatOptions = [], array $filters = []): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if (in_array($type, self::ATTRIBUTE_FILTER_TYPES)) {
-            $filters[] = $type;
-            $filters = array_unique($filters);
-        }
-
-        $size = $this->normalizeBigIntSize($type, $size);
-
-        $existsInSchema = false;
-
-        $schemaAttributes = $this->adapter->getSupportForSchemaAttributes()
-            ? $this->getSchemaAttributes($collection->getId())
-            : [];
-
-        try {
-            $attribute = $this->validateAttribute(
-                $collection,
-                $id,
-                $type,
-                $size,
-                $required,
-                $default,
-                $signed,
-                $array,
-                $format,
-                $formatOptions,
-                $filters,
-                $schemaAttributes
-            );
-        } catch (DuplicateException $e) {
-            // If the column exists in the physical schema but not in collection
-            // metadata, this is recovery from a partial failure where the column
-            // was created but metadata wasn't updated. Allow re-creation by
-            // skipping physical column creation and proceeding to metadata update.
-            // checkDuplicateId (metadata) runs before checkDuplicateInSchema, so
-            // if the attribute is absent from metadata the duplicate is in the
-            // physical schema only — a recoverable partial-failure state.
-            $existsInMetadata = false;
-            foreach ($collection->getAttribute('attributes', []) as $attr) {
-                if (\strtolower($attr->getAttribute('key', $attr->getId())) === \strtolower($id)) {
-                    $existsInMetadata = true;
-                    break;
-                }
-            }
-
-            if ($existsInMetadata) {
-                throw $e;
-            }
-
-            // Check if the existing schema column matches the requested type.
-            // If it matches we can skip column creation. If not, drop the
-            // orphaned column so it gets recreated with the correct type.
-            $typesMatch = true;
-            $expectedColumnType = $this->adapter->getColumnType($type, $size, $signed, $array, $required);
-            if ($expectedColumnType !== '') {
-                $filteredId = $this->adapter->filter($id);
-                foreach ($schemaAttributes as $schemaAttr) {
-                    $schemaId = $schemaAttr->getId();
-                    if (\strtolower($schemaId) === \strtolower($filteredId)) {
-                        $actualColumnType = \strtoupper($schemaAttr->getAttribute('columnType', ''));
-                        if ($actualColumnType !== \strtoupper($expectedColumnType)) {
-                            $typesMatch = false;
-                        }
-                        break;
-                    }
-                }
-            }
-
-            if (!$typesMatch) {
-                // Column exists with wrong type and is not tracked in metadata,
-                // so no indexes or relationships reference it. Drop and recreate.
-                $this->adapter->deleteAttribute($collection->getId(), $id);
-            } else {
-                $existsInSchema = true;
-            }
-
-            $attribute = new Document([
-                '$id' => ID::custom($id),
-                'key' => $id,
-                'type' => $type,
-                'size' => $size,
-                'required' => $required,
-                'default' => $default,
-                'signed' => $signed,
-                'array' => $array,
-                'format' => $format,
-                'formatOptions' => $formatOptions,
-                'filters' => $filters,
-            ]);
-        }
-
-        $created = false;
-
-        if (!$existsInSchema) {
-            try {
-                $created = $this->adapter->createAttribute($collection->getId(), $id, $type, $size, $signed, $array, $required);
-
-                if (!$created) {
-                    throw new DatabaseException('Failed to create attribute');
-                }
-            } catch (DuplicateException) {
-                // Attribute not in metadata (orphan detection above confirmed this).
-                // A DuplicateException from the adapter means the column exists only
-                // in physical schema — suppress and proceed to metadata update.
-            }
-        }
-
-        $collection->setAttribute('attributes', $attribute, Document::SET_TYPE_APPEND);
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->cleanupAttribute($collection->getId(), $id),
-            shouldRollback: $created,
-            operationDescription: "attribute creation '{$id}'"
-        );
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-                '$id' => $collection->getId(),
-                '$collection' => self::METADATA
-            ]));
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attribute);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Create Attribute
-     *
-     * @param string $collection
-     * @param array<array<string, mixed>> $attributes
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws StructureException
-     * @throws Exception
-     */
-    public function createAttributes(string $collection, array $attributes): bool
-    {
-        if (empty($attributes)) {
-            throw new DatabaseException('No attributes to create');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $schemaAttributes = $this->adapter->getSupportForSchemaAttributes()
-            ? $this->getSchemaAttributes($collection->getId())
-            : [];
-
-        $attributeDocuments = [];
-        $attributesToCreate = [];
-        foreach ($attributes as $attribute) {
-            if (!isset($attribute['$id'])) {
-                throw new DatabaseException('Missing attribute key');
-            }
-            if (!isset($attribute['type'])) {
-                throw new DatabaseException('Missing attribute type');
-            }
-            if (!isset($attribute['size'])) {
-                throw new DatabaseException('Missing attribute size');
-            }
-            if (!isset($attribute['required'])) {
-                throw new DatabaseException('Missing attribute required');
-            }
-            if (!isset($attribute['default'])) {
-                $attribute['default'] = null;
-            }
-            if (!isset($attribute['signed'])) {
-                $attribute['signed'] = true;
-            }
-            if (!isset($attribute['array'])) {
-                $attribute['array'] = false;
-            }
-            if (!isset($attribute['format'])) {
-                $attribute['format'] = null;
-            }
-            if (!isset($attribute['formatOptions'])) {
-                $attribute['formatOptions'] = [];
-            }
-            if (!isset($attribute['filters'])) {
-                $attribute['filters'] = [];
-            }
-
-            $attribute['size'] = $this->normalizeBigIntSize($attribute['type'], $attribute['size']);
-
-            $existsInSchema = false;
-
-            try {
-                $attributeDocument = $this->validateAttribute(
-                    $collection,
-                    $attribute['$id'],
-                    $attribute['type'],
-                    $attribute['size'],
-                    $attribute['required'],
-                    $attribute['default'],
-                    $attribute['signed'],
-                    $attribute['array'],
-                    $attribute['format'],
-                    $attribute['formatOptions'],
-                    $attribute['filters'],
-                    $schemaAttributes
-                );
-            } catch (DuplicateException $e) {
-                // Check if the duplicate is in metadata or only in schema
-                $existsInMetadata = false;
-                foreach ($collection->getAttribute('attributes', []) as $attr) {
-                    if (\strtolower($attr->getAttribute('key', $attr->getId())) === \strtolower($attribute['$id'])) {
-                        $existsInMetadata = true;
-                        break;
-                    }
-                }
-
-                if ($existsInMetadata) {
-                    throw $e;
-                }
-
-                // Schema-only orphan — check type match
-                $expectedColumnType = $this->adapter->getColumnType(
-                    $attribute['type'],
-                    $attribute['size'],
-                    $attribute['signed'],
-                    $attribute['array'],
-                    $attribute['required']
-                );
-                if ($expectedColumnType !== '') {
-                    $filteredId = $this->adapter->filter($attribute['$id']);
-                    foreach ($schemaAttributes as $schemaAttr) {
-                        if (\strtolower($schemaAttr->getId()) === \strtolower($filteredId)) {
-                            $actualColumnType = \strtoupper($schemaAttr->getAttribute('columnType', ''));
-                            if ($actualColumnType !== \strtoupper($expectedColumnType)) {
-                                // Type mismatch — drop orphaned column so it gets recreated
-                                $this->adapter->deleteAttribute($collection->getId(), $attribute['$id']);
-                            } else {
-                                $existsInSchema = true;
-                            }
-                            break;
-                        }
-                    }
-                }
-
-                $attributeDocument = new Document([
-                    '$id' => ID::custom($attribute['$id']),
-                    'key' => $attribute['$id'],
-                    'type' => $attribute['type'],
-                    'size' => $attribute['size'],
-                    'required' => $attribute['required'],
-                    'default' => $attribute['default'],
-                    'signed' => $attribute['signed'],
-                    'array' => $attribute['array'],
-                    'format' => $attribute['format'],
-                    'formatOptions' => $attribute['formatOptions'],
-                    'filters' => $attribute['filters'],
-                ]);
-            }
-
-            $attributeDocuments[] = $attributeDocument;
-            if (!$existsInSchema) {
-                $attributesToCreate[] = $attribute;
-            }
-        }
-
-        $created = false;
-
-        if (!empty($attributesToCreate)) {
-            try {
-                $created = $this->adapter->createAttributes($collection->getId(), $attributesToCreate);
-
-                if (!$created) {
-                    throw new DatabaseException('Failed to create attributes');
-                }
-            } catch (DuplicateException) {
-                // Batch failed because at least one column already exists.
-                // Fallback to per-attribute creation so non-duplicates still land in schema.
-                foreach ($attributesToCreate as $attr) {
-                    try {
-                        $this->adapter->createAttribute(
-                            $collection->getId(),
-                            $attr['$id'],
-                            $attr['type'],
-                            $attr['size'],
-                            $attr['signed'],
-                            $attr['array'],
-                            $attr['required']
-                        );
-                        $created = true;
-                    } catch (DuplicateException) {
-                        // Column already exists in schema — skip
-                    }
-                }
-            }
-        }
-
-        foreach ($attributeDocuments as $attributeDocument) {
-            $collection->setAttribute('attributes', $attributeDocument, Document::SET_TYPE_APPEND);
-        }
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->cleanupAttributes($collection->getId(), $attributeDocuments),
-            shouldRollback: $created,
-            operationDescription: 'attributes creation',
-            rollbackReturnsErrors: true
-        );
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-                '$id' => $collection->getId(),
-                '$collection' => self::METADATA
-            ]));
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $attributeDocuments);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Normalize BIGINT size metadata.
-     */
-    private function normalizeBigIntSize(string $type, int $size): int
-    {
-        return $type === self::VAR_BIGINT ? 0 : $size;
-    }
-
-    /**
-     * @param Document $collection
-     * @param string $id
-     * @param string $type
-     * @param int $size
-     * @param bool $required
-     * @param mixed $default
-     * @param bool $signed
-     * @param bool $array
-     * @param string $format
-     * @param array<string, mixed> $formatOptions
-     * @param array<string> $filters
-     * @param array<Document>|null $schemaAttributes Pre-fetched schema attributes, or null to fetch internally
-     * @return Document
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws Exception
-     */
-    private function validateAttribute(
-        Document $collection,
-        string $id,
-        string $type,
-        int $size,
-        bool $required,
-        mixed $default,
-        bool $signed,
-        bool $array,
-        ?string $format,
-        array $formatOptions,
-        array $filters,
-        ?array $schemaAttributes = null
-    ): Document {
-        $size = $this->normalizeBigIntSize($type, $size);
-
-        $attribute = new Document([
-            '$id' => ID::custom($id),
-            'key' => $id,
-            'type' => $type,
-            'size' => $size,
-            'required' => $required,
-            'default' => $default,
-            'signed' => $signed,
-            'array' => $array,
-            'format' => $format,
-            'formatOptions' => $formatOptions,
-            'filters' => $filters,
-        ]);
-
-        $collectionClone = clone $collection;
-        $collectionClone->setAttribute('attributes', $attribute, Document::SET_TYPE_APPEND);
-
-        $validator = new AttributeValidator(
-            attributes: $collection->getAttribute('attributes', []),
-            schemaAttributes: $schemaAttributes ?? ($this->adapter->getSupportForSchemaAttributes()
-                ? $this->getSchemaAttributes($collection->getId())
-                : []),
-            maxAttributes: $this->adapter->getLimitForAttributes(),
-            maxWidth: $this->adapter->getDocumentSizeLimit(),
-            maxStringLength: $this->adapter->getLimitForString(),
-            maxVarcharLength: $this->adapter->getMaxVarcharLength(),
-            maxIntLength: $this->adapter->getLimitForInt(),
-            maxBigIntLength: $this->adapter->getLimitForBigInt(),
-            supportForSchemaAttributes: $this->adapter->getSupportForSchemaAttributes(),
-            supportForVectors: $this->adapter->getSupportForVectors(),
-            supportForSpatialAttributes: $this->adapter->getSupportForSpatialAttributes(),
-            supportForObject: $this->adapter->getSupportForObject(),
-            supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-            attributeCountCallback: fn () => $this->adapter->getCountOfAttributes($collectionClone),
-            attributeWidthCallback: fn () => $this->adapter->getAttributeWidth($collectionClone),
-            filterCallback: fn ($id) => $this->adapter->filter($id),
-            isMigrating: $this->isMigrating(),
-            sharedTables: $this->getSharedTables(),
-        );
-
-        $validator->isValid($attribute);
-
-        return $attribute;
-    }
-
-    /**
-     * Get the list of required filters for each data type
-     *
-     * @param string|null $type Type of the attribute
-     *
-     * @return array<string>
-     */
-    protected function getRequiredFilters(?string $type): array
-    {
-        return match ($type) {
-            self::VAR_DATETIME => ['datetime'],
-            default => [],
-        };
-    }
-
-    /**
-     * Function to validate if the default value of an attribute matches its attribute type
-     *
-     * @param string $type Type of the attribute
-     * @param mixed $default Default value of the attribute
-     *
-     * @return void
-     * @throws DatabaseException
-     */
-    protected function validateDefaultTypes(string $type, mixed $default): void
-    {
-        $defaultType = \gettype($default);
-
-        if ($defaultType === 'NULL') {
-            // Disable null. No validation required
-            return;
-        }
-
-        if ($defaultType === 'array') {
-            // Spatial types require the array itself
-            if (!in_array($type, Database::SPATIAL_TYPES) && $type != Database::VAR_OBJECT) {
-                foreach ($default as $value) {
-                    $this->validateDefaultTypes($type, $value);
-                }
-            }
-            return;
-        }
-
-        switch ($type) {
-            case self::VAR_STRING:
-            case self::VAR_VARCHAR:
-            case self::VAR_TEXT:
-            case self::VAR_MEDIUMTEXT:
-            case self::VAR_LONGTEXT:
-                if ($defaultType !== 'string') {
-                    throw new DatabaseException('Default value ' . $default . ' does not match given type ' . $type);
-                }
-                break;
-            case self::VAR_INTEGER:
-            case self::VAR_FLOAT:
-            case self::VAR_BOOLEAN:
-                if ($type !== $defaultType) {
-                    throw new DatabaseException('Default value ' . $default . ' does not match given type ' . $type);
-                }
-                break;
-            case Database::VAR_BIGINT:
-                if ($defaultType !== 'integer' && $defaultType !== 'string') {
-                    throw new DatabaseException('Default value ' . $default . ' does not match given type ' . $type);
-                }
-                if ($defaultType === 'string' && !BigIntValidator::isIntegerString($default)) {
-                    throw new DatabaseException('Default value ' . $default . ' is not a valid integer string for type bigint');
-                }
-                break;
-            case self::VAR_DATETIME:
-                if ($defaultType !== self::VAR_STRING) {
-                    throw new DatabaseException('Default value ' . $default . ' does not match given type ' . $type);
-                }
-                break;
-            case self::VAR_VECTOR:
-                // When validating individual vector components (from recursion), they should be numeric
-                if ($defaultType !== 'double' && $defaultType !== 'integer') {
-                    throw new DatabaseException('Vector components must be numeric values (float or integer)');
-                }
-                break;
-            default:
-                $supportedTypes = [
-                    self::VAR_STRING,
-                    self::VAR_VARCHAR,
-                    self::VAR_TEXT,
-                    self::VAR_MEDIUMTEXT,
-                    self::VAR_LONGTEXT,
-                    self::VAR_INTEGER,
-                    self::VAR_BIGINT,
-                    self::VAR_FLOAT,
-                    self::VAR_BOOLEAN,
-                    self::VAR_DATETIME,
-                    self::VAR_RELATIONSHIP
-                ];
-                if ($this->adapter->getSupportForVectors()) {
-                    $supportedTypes[] = self::VAR_VECTOR;
-                }
-                if ($this->adapter->getSupportForSpatialAttributes()) {
-                    \array_push($supportedTypes, ...self::SPATIAL_TYPES);
-                }
-                throw new DatabaseException('Unknown attribute type: ' . $type . '. Must be one of ' . implode(', ', $supportedTypes));
-        }
-    }
-
-    /**
-     * Update attribute metadata. Utility method for update attribute methods.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param callable $updateCallback method that receives document, and returns it with changes applied
-     *
-     * @return Document
-     * @throws ConflictException
-     * @throws DatabaseException
-     */
-    protected function updateIndexMeta(string $collection, string $id, callable $updateCallback): Document
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->getId() === self::METADATA) {
-            throw new DatabaseException('Cannot update metadata indexes');
-        }
-
-        $indexes = $collection->getAttribute('indexes', []);
-        $index = \array_search($id, \array_map(fn ($index) => $index['$id'], $indexes));
-
-        if ($index === false) {
-            throw new NotFoundException('Index not found');
-        }
-
-        // Execute update from callback
-        $updateCallback($indexes[$index], $collection, $index);
-
-        $collection->setAttribute('indexes', $indexes);
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: null,
-            shouldRollback: false,
-            operationDescription: "index metadata update '{$id}'"
-        );
-
-        return $indexes[$index];
-    }
-
-    /**
-     * Update attribute metadata. Utility method for update attribute methods.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param callable(Document, Document, int|string): void $updateCallback method that receives document, and returns it with changes applied
-     *
-     * @return Document
-     * @throws ConflictException
-     * @throws DatabaseException
-     */
-    protected function updateAttributeMeta(string $collection, string $id, callable $updateCallback): Document
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->getId() === self::METADATA) {
-            throw new DatabaseException('Cannot update metadata attributes');
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $index = \array_search($id, \array_map(fn ($attribute) => $attribute['$id'], $attributes));
-
-        if ($index === false) {
-            throw new NotFoundException('Attribute not found');
-        }
-
-        // Execute update from callback
-        $updateCallback($attributes[$index], $collection, $index);
-
-        $collection->setAttribute('attributes', $attributes);
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: null,
-            shouldRollback: false,
-            operationDescription: "attribute metadata update '{$id}'"
-        );
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attributes[$index]);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $attributes[$index];
-    }
-
-    /**
-     * Update required status of attribute.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param bool $required
-     *
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttributeRequired(string $collection, string $id, bool $required): Document
-    {
-        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($required) {
-            $attribute->setAttribute('required', $required);
-        });
-    }
-
-    /**
-     * Update format of attribute.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $format validation format of attribute
-     *
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttributeFormat(string $collection, string $id, string $format): Document
-    {
-        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($format) {
-            if (!Structure::hasFormat($format, $attribute->getAttribute('type'))) {
-                throw new DatabaseException('Format "' . $format . '" not available for attribute type "' . $attribute->getAttribute('type') . '"');
-            }
-
-            $attribute->setAttribute('format', $format);
-        });
-    }
-
-    /**
-     * Update format options of attribute.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param array<string, mixed> $formatOptions assoc array with custom options that can be passed for the format validation
-     *
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttributeFormatOptions(string $collection, string $id, array $formatOptions): Document
-    {
-        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($formatOptions) {
-            $attribute->setAttribute('formatOptions', $formatOptions);
-        });
-    }
-
-    /**
-     * Update filters of attribute.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param array<string> $filters
-     *
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttributeFilters(string $collection, string $id, array $filters): Document
-    {
-        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($filters) {
-            $attribute->setAttribute('filters', $filters);
-        });
-    }
-
-    /**
-     * Update default value of attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param mixed $default
-     *
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttributeDefault(string $collection, string $id, mixed $default = null): Document
-    {
-        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($default) {
-            if ($attribute->getAttribute('required') === true) {
-                throw new DatabaseException('Cannot set a default value on a required attribute');
-            }
-
-            $this->validateDefaultTypes($attribute->getAttribute('type'), $default);
-
-            $attribute->setAttribute('default', $default);
-        });
-    }
-
-    /**
-     * Update Attribute. This method is for updating data that causes underlying structure to change. Check out other updateAttribute methods if you are looking for metadata adjustments.
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string|null $type
-     * @param int|null $size utf8mb4 chars length
-     * @param bool|null $required
-     * @param mixed $default
-     * @param bool $signed
-     * @param bool $array
-     * @param string|null $format
-     * @param array<string, mixed>|null $formatOptions
-     * @param array<string>|null $filters
-     * @param string|null $newKey
-     * @return Document
-     * @throws Exception
-     */
-    public function updateAttribute(string $collection, string $id, ?string $type = null, ?int $size = null, ?bool $required = null, mixed $default = null, ?bool $signed = null, ?bool $array = null, ?string $format = null, ?array $formatOptions = null, ?array $filters = null, ?string $newKey = null): Document
-    {
-        $collectionDoc = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collectionDoc->getId() === self::METADATA) {
-            throw new DatabaseException('Cannot update metadata attributes');
-        }
-
-        $attributes = $collectionDoc->getAttribute('attributes', []);
-        $attributeIndex = \array_search($id, \array_map(fn ($attribute) => $attribute['$id'], $attributes));
-
-        if ($attributeIndex === false) {
-            throw new NotFoundException('Attribute not found');
-        }
-
-        $attribute = $attributes[$attributeIndex];
-
-        $originalType = $attribute->getAttribute('type');
-        $originalSize = $attribute->getAttribute('size');
-        $originalSigned = $attribute->getAttribute('signed');
-        $originalArray = $attribute->getAttribute('array');
-        $originalRequired = $attribute->getAttribute('required');
-        $originalKey = $attribute->getAttribute('key');
-
-        $originalIndexes = [];
-        foreach ($collectionDoc->getAttribute('indexes', []) as $index) {
-            $originalIndexes[] = clone $index;
-        }
-
-        $altering = !\is_null($type)
-            || !\is_null($size)
-            || !\is_null($signed)
-            || !\is_null($array)
-            || !\is_null($newKey);
-        $type ??= $attribute->getAttribute('type');
-        $size ??= $attribute->getAttribute('size');
-        $signed ??= $attribute->getAttribute('signed');
-        $required ??= $attribute->getAttribute('required');
-        $default ??= $attribute->getAttribute('default');
-        $array ??= $attribute->getAttribute('array');
-        $format ??= $attribute->getAttribute('format');
-        $formatOptions ??= $attribute->getAttribute('formatOptions');
-        $filters ??= $attribute->getAttribute('filters');
-
-        $size = $this->normalizeBigIntSize($type, $size);
-
-        if ($required === true && !\is_null($default)) {
-            $default = null;
-        }
-
-        // we need to alter table attribute type to NOT NULL/NULL for change in required
-        if (!$this->adapter->getSupportForSpatialIndexNull() && in_array($type, Database::SPATIAL_TYPES)) {
-            $altering = true;
-        }
-
-        switch ($type) {
-            case self::VAR_STRING:
-                if (empty($size)) {
-                    throw new DatabaseException('Size length is required');
-                }
-
-                if ($size > $this->adapter->getLimitForString()) {
-                    throw new DatabaseException('Max size allowed for string is: ' . number_format($this->adapter->getLimitForString()));
-                }
-                break;
-
-            case self::VAR_VARCHAR:
-                if (empty($size)) {
-                    throw new DatabaseException('Size length is required');
-                }
-
-                if ($size > $this->adapter->getMaxVarcharLength()) {
-                    throw new DatabaseException('Max size allowed for varchar is: ' . number_format($this->adapter->getMaxVarcharLength()));
-                }
-                break;
-
-            case self::VAR_TEXT:
-            case self::VAR_MEDIUMTEXT:
-            case self::VAR_LONGTEXT:
-                // Text types don't require size validation as they have fixed max sizes
-                break;
-
-            case self::VAR_INTEGER:
-                $limit = ($signed) ? $this->adapter->getLimitForInt() / 2 : $this->adapter->getLimitForInt();
-                if ($size > $limit) {
-                    throw new DatabaseException('Max size allowed for int is: ' . number_format($limit));
-                }
-                break;
-            case self::VAR_BIGINT:
-                break;
-            case self::VAR_FLOAT:
-            case self::VAR_BOOLEAN:
-            case self::VAR_DATETIME:
-                if (!empty($size)) {
-                    throw new DatabaseException('Size must be empty');
-                }
-                break;
-            case self::VAR_OBJECT:
-                if (!$this->adapter->getSupportForObject()) {
-                    throw new DatabaseException('Object attributes are not supported');
-                }
-                if (!empty($size)) {
-                    throw new DatabaseException('Size must be empty for object attributes');
-                }
-                if (!empty($array)) {
-                    throw new DatabaseException('Object attributes cannot be arrays');
-                }
-                break;
-            case self::VAR_POINT:
-            case self::VAR_LINESTRING:
-            case self::VAR_POLYGON:
-                if (!$this->adapter->getSupportForSpatialAttributes()) {
-                    throw new DatabaseException('Spatial attributes are not supported');
-                }
-                if (!empty($size)) {
-                    throw new DatabaseException('Size must be empty for spatial attributes');
-                }
-                if (!empty($array)) {
-                    throw new DatabaseException('Spatial attributes cannot be arrays');
-                }
-                break;
-            case self::VAR_VECTOR:
-                if (!$this->adapter->getSupportForVectors()) {
-                    throw new DatabaseException('Vector types are not supported by the current database');
-                }
-                if ($array) {
-                    throw new DatabaseException('Vector type cannot be an array');
-                }
-                if ($size <= 0) {
-                    throw new DatabaseException('Vector dimensions must be a positive integer');
-                }
-                if ($size > self::MAX_VECTOR_DIMENSIONS) {
-                    throw new DatabaseException('Vector dimensions cannot exceed ' . self::MAX_VECTOR_DIMENSIONS);
-                }
-                if ($default !== null) {
-                    if (!\is_array($default)) {
-                        throw new DatabaseException('Vector default value must be an array');
-                    }
-                    if (\count($default) !== $size) {
-                        throw new DatabaseException('Vector default value must have exactly ' . $size . ' elements');
-                    }
-                    foreach ($default as $component) {
-                        if (!\is_int($component) && !\is_float($component)) {
-                            throw new DatabaseException('Vector default value must contain only numeric elements');
-                        }
-                    }
-                }
-                break;
-            default:
-                $supportedTypes = [
-                    self::VAR_STRING,
-                    self::VAR_VARCHAR,
-                    self::VAR_TEXT,
-                    self::VAR_MEDIUMTEXT,
-                    self::VAR_LONGTEXT,
-                    self::VAR_INTEGER,
-                    self::VAR_BIGINT,
-                    self::VAR_FLOAT,
-                    self::VAR_BOOLEAN,
-                    self::VAR_DATETIME,
-                    self::VAR_RELATIONSHIP
-                ];
-                if ($this->adapter->getSupportForVectors()) {
-                    $supportedTypes[] = self::VAR_VECTOR;
-                }
-                if ($this->adapter->getSupportForSpatialAttributes()) {
-                    \array_push($supportedTypes, ...self::SPATIAL_TYPES);
-                }
-                throw new DatabaseException('Unknown attribute type: ' . $type . '. Must be one of ' . implode(', ', $supportedTypes));
-        }
-
-        /** Ensure required filters for the attribute are passed */
-        $requiredFilters = $this->getRequiredFilters($type);
-        if (!empty(array_diff($requiredFilters, $filters))) {
-            throw new DatabaseException("Attribute of type: $type requires the following filters: " . implode(",", $requiredFilters));
-        }
-
-        if ($format) {
-            if (!Structure::hasFormat($format, $type)) {
-                throw new DatabaseException('Format ("' . $format . '") not available for this attribute type ("' . $type . '")');
-            }
-        }
-
-        if (!\is_null($default)) {
-            if ($required) {
-                throw new DatabaseException('Cannot set a default value on a required attribute');
-            }
-
-            $this->validateDefaultTypes($type, $default);
-        }
-
-        $attribute
-            ->setAttribute('$id', $newKey ?? $id)
-            ->setattribute('key', $newKey ?? $id)
-            ->setAttribute('type', $type)
-            ->setAttribute('size', $size)
-            ->setAttribute('signed', $signed)
-            ->setAttribute('array', $array)
-            ->setAttribute('format', $format)
-            ->setAttribute('formatOptions', $formatOptions)
-            ->setAttribute('filters', $filters)
-            ->setAttribute('required', $required)
-            ->setAttribute('default', $default);
-
-        $attributes = $collectionDoc->getAttribute('attributes');
-        $attributes[$attributeIndex] = $attribute;
-        $collectionDoc->setAttribute('attributes', $attributes, Document::SET_TYPE_ASSIGN);
-
-        if (
-            $this->adapter->getDocumentSizeLimit() > 0 &&
-            $this->adapter->getAttributeWidth($collectionDoc) >= $this->adapter->getDocumentSizeLimit()
-        ) {
-            throw new LimitException('Row width limit reached. Cannot update attribute.');
-        }
-
-        if (in_array($type, self::SPATIAL_TYPES, true) && !$this->adapter->getSupportForSpatialIndexNull()) {
-            $attributeMap = [];
-            foreach ($attributes as $attrDoc) {
-                $key = \strtolower($attrDoc->getAttribute('key', $attrDoc->getAttribute('$id')));
-                $attributeMap[$key] = $attrDoc;
-            }
-
-            $indexes = $collectionDoc->getAttribute('indexes', []);
-            foreach ($indexes as $index) {
-                if ($index->getAttribute('type') !== self::INDEX_SPATIAL) {
-                    continue;
-                }
-                $indexAttributes = $index->getAttribute('attributes', []);
-                foreach ($indexAttributes as $attributeName) {
-                    $lookup = \strtolower($attributeName);
-                    if (!isset($attributeMap[$lookup])) {
-                        continue;
-                    }
-                    $attrDoc = $attributeMap[$lookup];
-                    $attrType = $attrDoc->getAttribute('type');
-                    $attrRequired = (bool)$attrDoc->getAttribute('required', false);
-
-                    if (in_array($attrType, self::SPATIAL_TYPES, true) && !$attrRequired) {
-                        throw new IndexException('Spatial indexes do not allow null values. Mark the attribute "' . $attributeName . '" as required or create the index on a column with no null values.');
-                    }
-                }
-            }
-        }
-
-        $updated = false;
-
-        if ($altering) {
-            $indexes = $collectionDoc->getAttribute('indexes');
-
-            if (!\is_null($newKey) && $id !== $newKey) {
-                foreach ($indexes as $index) {
-                    if (in_array($id, $index['attributes'])) {
-                        $index['attributes'] = array_map(function ($attribute) use ($id, $newKey) {
-                            return $attribute === $id ? $newKey : $attribute;
-                        }, $index['attributes']);
-                    }
-                }
-
-                /**
-                 * Check index dependency if we are changing the key
-                 */
-                $validator = new IndexDependencyValidator(
-                    $collectionDoc->getAttribute('indexes', []),
-                    $this->adapter->getSupportForCastIndexArray(),
-                );
-
-                if (!$validator->isValid($attribute)) {
-                    throw new DependencyException($validator->getDescription());
-                }
-            }
-
-            /**
-             * Since we allow changing type & size we need to validate index length
-             */
-            if ($this->validate) {
-                $validator = new IndexValidator(
-                    $attributes,
-                    $originalIndexes,
-                    $this->adapter->getMaxIndexLength(),
-                    $this->adapter->getInternalIndexesKeys(),
-                    $this->adapter->getSupportForIndexArray(),
-                    $this->adapter->getSupportForSpatialIndexNull(),
-                    $this->adapter->getSupportForSpatialIndexOrder(),
-                    $this->adapter->getSupportForVectors(),
-                    $this->adapter->getSupportForAttributes(),
-                    $this->adapter->getSupportForMultipleFulltextIndexes(),
-                    $this->adapter->getSupportForIdenticalIndexes(),
-                    $this->adapter->getSupportForObjectIndexes(),
-                    $this->adapter->getSupportForTrigramIndex(),
-                    $this->adapter->getSupportForSpatialAttributes(),
-                    $this->adapter->getSupportForIndex(),
-                    $this->adapter->getSupportForUniqueIndex(),
-                    $this->adapter->getSupportForFulltextIndex(),
-                    $this->adapter->getSupportForTTLIndexes(),
-                    $this->adapter->getSupportForObject()
-                );
-
-                foreach ($indexes as $index) {
-                    if (!$validator->isValid($index)) {
-                        throw new IndexException($validator->getDescription());
-                    }
-                }
-            }
-
-            $updated = $this->adapter->updateAttribute($collection, $id, $type, $size, $signed, $array, $newKey, $required);
-
-            if (!$updated) {
-                throw new DatabaseException('Failed to update attribute');
-            }
-        }
-
-        $collectionDoc->setAttribute('attributes', $attributes);
-
-        $this->updateMetadata(
-            collection: $collectionDoc,
-            rollbackOperation: fn () => $this->adapter->updateAttribute(
-                $collection,
-                $newKey ?? $id,
-                $originalType,
-                (int)$originalSize,
-                $originalSigned,
-                $originalArray,
-                $originalKey,
-                $originalRequired
-            ),
-            shouldRollback: $updated,
-            operationDescription: "attribute update '{$id}'",
-            silentRollback: true
-        );
-
-        if ($altering) {
-            $this->withRetries(fn () => $this->purgeCachedCollection($collection));
-        }
-        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection));
-
-        try {
-            $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-                '$id' => $collection,
-                '$collection' => self::METADATA
-            ]));
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $attribute;
-    }
-
-    /**
-     * Checks if attribute can be added to collection.
-     * Used to check attribute limits without asking the database
-     * Returns true if attribute can be added to collection, throws exception otherwise
-     *
-     * @param Document $collection
-     * @param Document $attribute
-     *
-     * @return bool
-     * @throws LimitException
-     */
-    public function checkAttribute(Document $collection, Document $attribute): bool
-    {
-        $collection = clone $collection;
-
-        $collection->setAttribute('attributes', $attribute, Document::SET_TYPE_APPEND);
-
-        if (
-            $this->adapter->getLimitForAttributes() > 0 &&
-            $this->adapter->getCountOfAttributes($collection) > $this->adapter->getLimitForAttributes()
-        ) {
-            throw new LimitException('Column limit reached. Cannot create new attribute. Current attribute count is ' . $this->adapter->getCountOfAttributes($collection) . ' but the maximum is ' . $this->adapter->getLimitForAttributes() . '. Remove some attributes to free up space.');
-        }
-
-        if (
-            $this->adapter->getDocumentSizeLimit() > 0 &&
-            $this->adapter->getAttributeWidth($collection) >= $this->adapter->getDocumentSizeLimit()
-        ) {
-            throw new LimitException('Row width limit reached. Cannot create new attribute. Current row width is ' . $this->adapter->getAttributeWidth($collection) . ' bytes but the maximum is ' . $this->adapter->getDocumentSizeLimit() . ' bytes. Reduce the size of existing attributes or remove some attributes to free up space.');
-        }
-
-        return true;
-    }
-
-    /**
-     * Delete Attribute
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     * @throws ConflictException
-     * @throws DatabaseException
-     */
-    public function deleteAttribute(string $collection, string $id): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $attribute = null;
-
-        foreach ($attributes as $key => $value) {
-            if (isset($value['$id']) && $value['$id'] === $id) {
-                $attribute = $value;
-                unset($attributes[$key]);
-                break;
-            }
-        }
-
-        if (\is_null($attribute)) {
-            throw new NotFoundException('Attribute not found');
-        }
-
-        if ($attribute['type'] === self::VAR_RELATIONSHIP) {
-            throw new DatabaseException('Cannot delete relationship as an attribute');
-        }
-
-        if ($this->validate) {
-            $validator = new IndexDependencyValidator(
-                $collection->getAttribute('indexes', []),
-                $this->adapter->getSupportForCastIndexArray(),
-            );
-
-            if (!$validator->isValid($attribute)) {
-                throw new DependencyException($validator->getDescription());
-            }
-        }
-
-        foreach ($indexes as $indexKey => $index) {
-            $indexAttributes = $index->getAttribute('attributes', []);
-
-            $indexAttributes = \array_filter($indexAttributes, fn ($attribute) => $attribute !== $id);
-
-            if (empty($indexAttributes)) {
-                unset($indexes[$indexKey]);
-            } else {
-                $index->setAttribute('attributes', \array_values($indexAttributes));
-            }
-        }
-
-        $collection->setAttribute('attributes', \array_values($attributes));
-        $collection->setAttribute('indexes', \array_values($indexes));
-
-        $shouldRollback = false;
-        try {
-            if (!$this->adapter->deleteAttribute($collection->getId(), $id)) {
-                throw new DatabaseException('Failed to delete attribute');
-            }
-            $shouldRollback = true;
-        } catch (NotFoundException) {
-            // Ignore
-        }
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->adapter->createAttribute(
-                $collection->getId(),
-                $id,
-                $attribute['type'],
-                $attribute['size'],
-                $attribute['signed'] ?? true,
-                $attribute['array'] ?? false,
-                $attribute['required'] ?? false
-            ),
-            shouldRollback: $shouldRollback,
-            operationDescription: "attribute deletion '{$id}'",
-            silentRollback: true
-        );
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-                '$id' => $collection->getId(),
-                '$collection' => self::METADATA
-            ]));
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $attribute);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Rename Attribute
-     *
-     * @param string $collection
-     * @param string $old Current attribute ID
-     * @param string $new
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws StructureException
-     */
-    public function renameAttribute(string $collection, string $old, string $new): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        /**
-         * @var array<Document> $attributes
-         */
-        $attributes = $collection->getAttribute('attributes', []);
-
-        /**
-         * @var array<Document> $indexes
-         */
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $attribute = new Document();
-
-        foreach ($attributes as $value) {
-            if ($value->getId() === $old) {
-                $attribute = $value;
-            }
-
-            if ($value->getId() === $new) {
-                throw new DuplicateException('Attribute name already used');
-            }
-        }
-
-        if ($attribute->isEmpty()) {
-            throw new NotFoundException('Attribute not found');
-        }
-
-        if ($this->validate) {
-            $validator = new IndexDependencyValidator(
-                $collection->getAttribute('indexes', []),
-                $this->adapter->getSupportForCastIndexArray(),
-            );
-
-            if (!$validator->isValid($attribute)) {
-                throw new DependencyException($validator->getDescription());
-            }
-        }
-
-        $attribute->setAttribute('$id', $new);
-        $attribute->setAttribute('key', $new);
-
-        foreach ($indexes as $index) {
-            $indexAttributes = $index->getAttribute('attributes', []);
-
-            $indexAttributes = \array_map(fn ($attr) => ($attr === $old) ? $new : $attr, $indexAttributes);
-
-            $index->setAttribute('attributes', $indexAttributes);
-        }
-
-        $renamed = false;
-        try {
-            $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
-            if (!$renamed) {
-                throw new DatabaseException('Failed to rename attribute');
-            }
-        } catch (\Throwable $e) {
-            // Check if the rename already happened in schema (orphan from prior
-            // partial failure where rename succeeded but metadata update failed).
-            // We verified $new doesn't exist in metadata (above), so if $new
-            // exists in schema, it must be from a prior rename.
-            if ($this->adapter->getSupportForSchemaAttributes()) {
-                $schemaAttributes = $this->getSchemaAttributes($collection->getId());
-                $filteredNew = $this->adapter->filter($new);
-                $newExistsInSchema = false;
-                foreach ($schemaAttributes as $schemaAttr) {
-                    if (\strtolower($schemaAttr->getId()) === \strtolower($filteredNew)) {
-                        $newExistsInSchema = true;
-                        break;
-                    }
-                }
-                if ($newExistsInSchema) {
-                    $renamed = true;
-                } else {
-                    throw new DatabaseException("Failed to rename attribute '{$old}' to '{$new}': " . $e->getMessage(), previous: $e);
-                }
-            } else {
-                throw new DatabaseException("Failed to rename attribute '{$old}' to '{$new}': " . $e->getMessage(), previous: $e);
-            }
-        }
-
-        $collection->setAttribute('attributes', $attributes);
-        $collection->setAttribute('indexes', $indexes);
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->adapter->renameAttribute($collection->getId(), $new, $old),
-            shouldRollback: $renamed,
-            operationDescription: "attribute rename '{$old}' to '{$new}'"
-        );
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_UPDATE, $attribute);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $renamed;
-    }
-
-    /**
-     * Cleanup (delete) a single attribute with retry logic
-     *
-     * @param string $collectionId The collection ID
-     * @param string $attributeId The attribute ID
-     * @param int $maxAttempts Maximum retry attempts
-     * @return void
-     * @throws DatabaseException If cleanup fails after all retries
-     */
-    private function cleanupAttribute(
-        string $collectionId,
-        string $attributeId,
-        int $maxAttempts = 3
-    ): void {
-        $this->cleanup(
-            fn () => $this->adapter->deleteAttribute($collectionId, $attributeId),
-            'attribute',
-            $attributeId,
-            $maxAttempts
-        );
-    }
-
-    /**
-     * Cleanup (delete) multiple attributes with retry logic
-     *
-     * @param string $collectionId The collection ID
-     * @param array<Document> $attributeDocuments The attribute documents to cleanup
-     * @param int $maxAttempts Maximum retry attempts per attribute
-     * @return array<string> Array of error messages for failed cleanups (empty if all succeeded)
-     */
-    private function cleanupAttributes(
-        string $collectionId,
-        array $attributeDocuments,
-        int $maxAttempts = 3
-    ): array {
-        $errors = [];
-
-        foreach ($attributeDocuments as $attributeDocument) {
-            try {
-                $this->cleanupAttribute($collectionId, $attributeDocument->getId(), $maxAttempts);
-            } catch (DatabaseException $e) {
-                // Continue cleaning up other attributes even if one fails
-                $errors[] = $e->getMessage();
-            }
-        }
-
-        return $errors;
-    }
-
-    /**
-     * Cleanup (delete) a collection with retry logic
-     *
-     * @param string $collectionId The collection ID
-     * @param int $maxAttempts Maximum retry attempts
-     * @return void
-     * @throws DatabaseException If cleanup fails after all retries
-     */
-    private function cleanupCollection(
-        string $collectionId,
-        int $maxAttempts = 3
-    ): void {
-        $this->cleanup(
-            fn () => $this->adapter->deleteCollection($collectionId),
-            'collection',
-            $collectionId,
-            $maxAttempts
-        );
-    }
-
-    /**
-     * Cleanup (delete) a relationship with retry logic
-     *
-     * @param string $collectionId The collection ID
-     * @param string $relatedCollectionId The related collection ID
-     * @param string $type The relationship type
-     * @param bool $twoWay Whether the relationship is two-way
-     * @param string $key The relationship key
-     * @param string $twoWayKey The two-way relationship key
-     * @param string $side The relationship side
-     * @param int $maxAttempts Maximum retry attempts
-     * @return void
-     * @throws DatabaseException If cleanup fails after all retries
-     */
-    private function cleanupRelationship(
-        string $collectionId,
-        string $relatedCollectionId,
-        string $type,
-        bool $twoWay,
-        string $key,
-        string $twoWayKey,
-        string $side = Database::RELATION_SIDE_PARENT,
-        int $maxAttempts = 3
-    ): void {
-        $this->cleanup(
-            fn () => $this->adapter->deleteRelationship(
-                $collectionId,
-                $relatedCollectionId,
-                $type,
-                $twoWay,
-                $key,
-                $twoWayKey,
-                $side
-            ),
-            'relationship',
-            $key,
-            $maxAttempts
-        );
-    }
-
-    /**
-     * Create a relationship attribute
-     *
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string|null $id
-     * @param string|null $twoWayKey
-     * @param string $onDelete
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws StructureException
-     */
-    public function createRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay = false,
-        ?string $id = null,
-        ?string $twoWayKey = null,
-        string $onDelete = Database::RELATION_MUTATE_RESTRICT
-    ): bool {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $relatedCollection = $this->silent(fn () => $this->getCollection($relatedCollection));
-
-        if ($relatedCollection->isEmpty()) {
-            throw new NotFoundException('Related collection not found');
-        }
-
-        $id ??= $relatedCollection->getId();
-
-        $twoWayKey ??= $collection->getId();
-
-        $attributes = $collection->getAttribute('attributes', []);
-        /** @var array<Document> $attributes */
-        foreach ($attributes as $attribute) {
-            if (\strtolower($attribute->getId()) === \strtolower($id)) {
-                throw new DuplicateException('Attribute already exists');
-            }
-
-            if (
-                $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
-                && \strtolower($attribute->getAttribute('options')['twoWayKey']) === \strtolower($twoWayKey)
-                && $attribute->getAttribute('options')['relatedCollection'] === $relatedCollection->getId()
-            ) {
-                throw new DuplicateException('Related attribute already exists');
-            }
-        }
-
-        $relationship = new Document([
-            '$id' => ID::custom($id),
-            'key' => $id,
-            'type' => Database::VAR_RELATIONSHIP,
-            'required' => false,
-            'default' => null,
-            'options' => [
-                'relatedCollection' => $relatedCollection->getId(),
-                'relationType' => $type,
-                'twoWay' => $twoWay,
-                'twoWayKey' => $twoWayKey,
-                'onDelete' => $onDelete,
-                'side' => Database::RELATION_SIDE_PARENT,
-            ],
-        ]);
-
-        $twoWayRelationship = new Document([
-            '$id' => ID::custom($twoWayKey),
-            'key' => $twoWayKey,
-            'type' => Database::VAR_RELATIONSHIP,
-            'required' => false,
-            'default' => null,
-            'options' => [
-                'relatedCollection' => $collection->getId(),
-                'relationType' => $type,
-                'twoWay' => $twoWay,
-                'twoWayKey' => $id,
-                'onDelete' => $onDelete,
-                'side' => Database::RELATION_SIDE_CHILD,
-            ],
-        ]);
-
-        $this->checkAttribute($collection, $relationship);
-        $this->checkAttribute($relatedCollection, $twoWayRelationship);
-
-        $junctionCollection = null;
-        if ($type === self::RELATION_MANY_TO_MANY) {
-            $junctionCollection = '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence();
-            $junctionAttributes = [
-                new Document([
-                    '$id' => $id,
-                    'key' => $id,
-                    'type' => self::VAR_STRING,
-                    'size' => Database::LENGTH_KEY,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => $twoWayKey,
-                    'key' => $twoWayKey,
-                    'type' => self::VAR_STRING,
-                    'size' => Database::LENGTH_KEY,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ];
-            $junctionIndexes = [
-                new Document([
-                    '$id' => '_index_' . $id,
-                    'key' => 'index_' . $id,
-                    'type' => self::INDEX_KEY,
-                    'attributes' => [$id],
-                ]),
-                new Document([
-                    '$id' => '_index_' . $twoWayKey,
-                    'key' => '_index_' . $twoWayKey,
-                    'type' => self::INDEX_KEY,
-                    'attributes' => [$twoWayKey],
-                ]),
-            ];
-            try {
-                $this->silent(fn () => $this->createCollection($junctionCollection, $junctionAttributes, $junctionIndexes));
-            } catch (DuplicateException) {
-                // Junction metadata already exists from a prior partial failure.
-                // Ensure the physical schema also exists.
-                try {
-                    $this->adapter->createCollection($junctionCollection, $junctionAttributes, $junctionIndexes);
-                } catch (DuplicateException) {
-                    // Schema already exists — ignore
-                }
-            }
-        }
-
-        $created = false;
-
-        try {
-            $created = $this->adapter->createRelationship(
-                $collection->getId(),
-                $relatedCollection->getId(),
-                $type,
-                $twoWay,
-                $id,
-                $twoWayKey
-            );
-
-            if (!$created) {
-                if ($junctionCollection !== null) {
-                    try {
-                        $this->silent(fn () => $this->cleanupCollection($junctionCollection));
-                    } catch (\Throwable $e) {
-                        Console::error("Failed to cleanup junction collection '{$junctionCollection}': " . $e->getMessage());
-                    }
-                }
-                throw new DatabaseException('Failed to create relationship');
-            }
-        } catch (DuplicateException) {
-            // Metadata checks (above) already verified relationship is absent
-            // from metadata. A DuplicateException from the adapter means the
-            // relationship exists only in physical schema — an orphan from a
-            // prior partial failure. Skip creation and proceed to metadata update.
-        }
-
-        $collection->setAttribute('attributes', $relationship, Document::SET_TYPE_APPEND);
-        $relatedCollection->setAttribute('attributes', $twoWayRelationship, Document::SET_TYPE_APPEND);
-
-        $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $junctionCollection, $created) {
-            $indexesCreated = [];
-            try {
-                $this->withRetries(function () use ($collection, $relatedCollection) {
-                    $this->withTransaction(function () use ($collection, $relatedCollection) {
-                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
-                        $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
-                    });
-                });
-            } catch (\Throwable $e) {
-                $this->rollbackAttributeMetadata($collection, [$id]);
-                $this->rollbackAttributeMetadata($relatedCollection, [$twoWayKey]);
-
-                if ($created) {
-                    try {
-                        $this->cleanupRelationship(
-                            $collection->getId(),
-                            $relatedCollection->getId(),
-                            $type,
-                            $twoWay,
-                            $id,
-                            $twoWayKey,
-                            Database::RELATION_SIDE_PARENT
-                        );
-                    } catch (\Throwable $e) {
-                        Console::error("Failed to cleanup relationship '{$id}': " . $e->getMessage());
-                    }
-
-                    if ($junctionCollection !== null) {
-                        try {
-                            $this->cleanupCollection($junctionCollection);
-                        } catch (\Throwable $e) {
-                            Console::error("Failed to cleanup junction collection '{$junctionCollection}': " . $e->getMessage());
-                        }
-                    }
-                }
-
-                throw new DatabaseException('Failed to create relationship: ' . $e->getMessage());
-            }
-
-            $indexKey = '_index_' . $id;
-            $twoWayIndexKey = '_index_' . $twoWayKey;
-            $indexesCreated = [];
-
-            try {
-                switch ($type) {
-                    case self::RELATION_ONE_TO_ONE:
-                        $this->createIndex($collection->getId(), $indexKey, self::INDEX_UNIQUE, [$id]);
-                        $indexesCreated[] = ['collection' => $collection->getId(), 'index' => $indexKey];
-                        if ($twoWay) {
-                            $this->createIndex($relatedCollection->getId(), $twoWayIndexKey, self::INDEX_UNIQUE, [$twoWayKey]);
-                            $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
-                        }
-                        break;
-                    case self::RELATION_ONE_TO_MANY:
-                        $this->createIndex($relatedCollection->getId(), $twoWayIndexKey, self::INDEX_KEY, [$twoWayKey]);
-                        $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
-                        break;
-                    case self::RELATION_MANY_TO_ONE:
-                        $this->createIndex($collection->getId(), $indexKey, self::INDEX_KEY, [$id]);
-                        $indexesCreated[] = ['collection' => $collection->getId(), 'index' => $indexKey];
-                        break;
-                    case self::RELATION_MANY_TO_MANY:
-                        // Indexes created on junction collection creation
-                        break;
-                    default:
-                        throw new RelationshipException('Invalid relationship type.');
-                }
-            } catch (\Throwable $e) {
-                foreach ($indexesCreated as $indexInfo) {
-                    try {
-                        $this->deleteIndex($indexInfo['collection'], $indexInfo['index']);
-                    } catch (\Throwable $cleanupError) {
-                        Console::error("Failed to cleanup index '{$indexInfo['index']}': " . $cleanupError->getMessage());
-                    }
-                }
-
-                try {
-                    $this->withTransaction(function () use ($collection, $relatedCollection, $id, $twoWayKey) {
-                        $attributes = $collection->getAttribute('attributes', []);
-                        $collection->setAttribute('attributes', array_filter($attributes, fn ($attr) => $attr->getId() !== $id));
-                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
-
-                        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
-                        $relatedCollection->setAttribute('attributes', array_filter($relatedAttributes, fn ($attr) => $attr->getId() !== $twoWayKey));
-                        $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
-                    });
-                } catch (\Throwable $cleanupError) {
-                    Console::error("Failed to cleanup metadata for relationship '{$id}': " . $cleanupError->getMessage());
-                }
-
-                // Cleanup relationship
-                try {
-                    $this->cleanupRelationship(
-                        $collection->getId(),
-                        $relatedCollection->getId(),
-                        $type,
-                        $twoWay,
-                        $id,
-                        $twoWayKey,
-                        Database::RELATION_SIDE_PARENT
-                    );
-                } catch (\Throwable $cleanupError) {
-                    Console::error("Failed to cleanup relationship '{$id}': " . $cleanupError->getMessage());
-                }
-
-                if ($junctionCollection !== null) {
-                    try {
-                        $this->cleanupCollection($junctionCollection);
-                    } catch (\Throwable $cleanupError) {
-                        Console::error("Failed to cleanup junction collection '{$junctionCollection}': " . $cleanupError->getMessage());
-                    }
-                }
-
-                throw new DatabaseException('Failed to create relationship indexes: ' . $e->getMessage());
-            }
-        });
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_CREATE, $relationship);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Update a relationship attribute
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string|null $newKey
-     * @param string|null $newTwoWayKey
-     * @param bool|null $twoWay
-     * @param string|null $onDelete
-     * @return bool
-     * @throws ConflictException
-     * @throws DatabaseException
-     */
-    public function updateRelationship(
-        string $collection,
-        string $id,
-        ?string $newKey = null,
-        ?string $newTwoWayKey = null,
-        ?bool $twoWay = null,
-        ?string $onDelete = null
-    ): bool {
-        if (
-            \is_null($newKey)
-            && \is_null($newTwoWayKey)
-            && \is_null($twoWay)
-            && \is_null($onDelete)
-        ) {
-            return true;
-        }
-
-        $collection = $this->getCollection($collection);
-        $attributes = $collection->getAttribute('attributes', []);
-
-        if (
-            !\is_null($newKey)
-            && \in_array($newKey, \array_map(fn ($attribute) => $attribute['key'], $attributes))
-        ) {
-            throw new DuplicateException('Relationship already exists');
-        }
-
-        $attributeIndex = array_search($id, array_map(fn ($attribute) => $attribute['$id'], $attributes));
-
-        if ($attributeIndex === false) {
-            throw new NotFoundException('Relationship not found');
-        }
-
-        $attribute = $attributes[$attributeIndex];
-        $type = $attribute['options']['relationType'];
-        $side = $attribute['options']['side'];
-
-        $relatedCollectionId = $attribute['options']['relatedCollection'];
-        $relatedCollection = $this->getCollection($relatedCollectionId);
-
-        // Determine if we need to alter the database (rename columns/indexes)
-        $oldAttribute = $attributes[$attributeIndex];
-        $oldTwoWayKey = $oldAttribute['options']['twoWayKey'];
-        $altering = (!\is_null($newKey) && $newKey !== $id)
-            || (!\is_null($newTwoWayKey) && $newTwoWayKey !== $oldTwoWayKey);
-
-        // Validate new keys don't already exist
-        if (
-            !\is_null($newTwoWayKey)
-            && \in_array($newTwoWayKey, \array_map(fn ($attribute) => $attribute['key'], $relatedCollection->getAttribute('attributes', [])))
-        ) {
-            throw new DuplicateException('Related attribute already exists');
-        }
-
-        $actualNewKey = $newKey ?? $id;
-        $actualNewTwoWayKey = $newTwoWayKey ?? $oldTwoWayKey;
-        $actualTwoWay = $twoWay ?? $oldAttribute['options']['twoWay'];
-        $actualOnDelete = $onDelete ?? $oldAttribute['options']['onDelete'];
-
-        $adapterUpdated = false;
-        if ($altering) {
-            try {
-                $adapterUpdated = $this->adapter->updateRelationship(
-                    $collection->getId(),
-                    $relatedCollection->getId(),
-                    $type,
-                    $actualTwoWay,
-                    $id,
-                    $oldTwoWayKey,
-                    $side,
-                    $actualNewKey,
-                    $actualNewTwoWayKey
-                );
-
-                if (!$adapterUpdated) {
-                    throw new DatabaseException('Failed to update relationship');
-                }
-            } catch (\Throwable $e) {
-                // Check if the rename already happened in schema (orphan from prior
-                // partial failure where adapter succeeded but metadata+rollback failed).
-                // If the new column names already exist, the prior rename completed.
-                if ($this->adapter->getSupportForSchemaAttributes()) {
-                    $schemaAttributes = $this->getSchemaAttributes($collection->getId());
-                    $filteredNewKey = $this->adapter->filter($actualNewKey);
-                    $newKeyExists = false;
-                    foreach ($schemaAttributes as $schemaAttr) {
-                        if (\strtolower($schemaAttr->getId()) === \strtolower($filteredNewKey)) {
-                            $newKeyExists = true;
-                            break;
-                        }
-                    }
-                    if ($newKeyExists) {
-                        $adapterUpdated = true;
-                    } else {
-                        throw new DatabaseException("Failed to update relationship '{$id}': " . $e->getMessage(), previous: $e);
-                    }
-                } else {
-                    throw new DatabaseException("Failed to update relationship '{$id}': " . $e->getMessage(), previous: $e);
-                }
-            }
-        }
-
-        try {
-            $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($actualNewKey, $actualNewTwoWayKey, $actualTwoWay, $actualOnDelete, $relatedCollection, $type, $side) {
-                $attribute->setAttribute('$id', $actualNewKey);
-                $attribute->setAttribute('key', $actualNewKey);
-                $attribute->setAttribute('options', [
-                    'relatedCollection' => $relatedCollection->getId(),
-                    'relationType' => $type,
-                    'twoWay' => $actualTwoWay,
-                    'twoWayKey' => $actualNewTwoWayKey,
-                    'onDelete' => $actualOnDelete,
-                    'side' => $side,
-                ]);
-            });
-
-            $this->updateAttributeMeta($relatedCollection->getId(), $oldTwoWayKey, function ($twoWayAttribute) use ($actualNewKey, $actualNewTwoWayKey, $actualTwoWay, $actualOnDelete) {
-                $options = $twoWayAttribute->getAttribute('options', []);
-                $options['twoWayKey'] = $actualNewKey;
-                $options['twoWay'] = $actualTwoWay;
-                $options['onDelete'] = $actualOnDelete;
-
-                $twoWayAttribute->setAttribute('$id', $actualNewTwoWayKey);
-                $twoWayAttribute->setAttribute('key', $actualNewTwoWayKey);
-                $twoWayAttribute->setAttribute('options', $options);
-            });
-
-            if ($type === self::RELATION_MANY_TO_MANY) {
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                $this->updateAttributeMeta($junction, $id, function ($junctionAttribute) use ($actualNewKey) {
-                    $junctionAttribute->setAttribute('$id', $actualNewKey);
-                    $junctionAttribute->setAttribute('key', $actualNewKey);
-                });
-                $this->updateAttributeMeta($junction, $oldTwoWayKey, function ($junctionAttribute) use ($actualNewTwoWayKey) {
-                    $junctionAttribute->setAttribute('$id', $actualNewTwoWayKey);
-                    $junctionAttribute->setAttribute('key', $actualNewTwoWayKey);
-                });
-
-                $this->withRetries(fn () => $this->purgeCachedCollection($junction));
-            }
-        } catch (\Throwable $e) {
-            if ($adapterUpdated) {
-                try {
-                    $this->adapter->updateRelationship(
-                        $collection->getId(),
-                        $relatedCollection->getId(),
-                        $type,
-                        $actualTwoWay,
-                        $actualNewKey,
-                        $actualNewTwoWayKey,
-                        $side,
-                        $id,
-                        $oldTwoWayKey
-                    );
-                } catch (\Throwable $e) {
-                    // Ignore
-                }
-            }
-            throw $e;
-        }
-
-        // Update Indexes — wrapped in rollback for consistency with metadata
-        $renameIndex = function (string $collection, string $key, string $newKey) {
-            $this->updateIndexMeta(
-                $collection,
-                '_index_' . $key,
-                function ($index) use ($newKey) {
-                    $index->setAttribute('attributes', [$newKey]);
-                }
-            );
-            $this->silent(
-                fn () => $this->renameIndex($collection, '_index_' . $key, '_index_' . $newKey)
-            );
-        };
-
-        $indexRenamesCompleted = [];
-
-        try {
-            switch ($type) {
-                case self::RELATION_ONE_TO_ONE:
-                    if ($id !== $actualNewKey) {
-                        $renameIndex($collection->getId(), $id, $actualNewKey);
-                        $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
-                    }
-                    if ($actualTwoWay && $oldTwoWayKey !== $actualNewTwoWayKey) {
-                        $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
-                        $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
-                    }
-                    break;
-                case self::RELATION_ONE_TO_MANY:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        if ($oldTwoWayKey !== $actualNewTwoWayKey) {
-                            $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
-                            $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
-                        }
-                    } else {
-                        if ($id !== $actualNewKey) {
-                            $renameIndex($collection->getId(), $id, $actualNewKey);
-                            $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
-                        }
-                    }
-                    break;
-                case self::RELATION_MANY_TO_ONE:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        if ($id !== $actualNewKey) {
-                            $renameIndex($collection->getId(), $id, $actualNewKey);
-                            $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
-                        }
-                    } else {
-                        if ($oldTwoWayKey !== $actualNewTwoWayKey) {
-                            $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
-                            $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
-                        }
-                    }
-                    break;
-                case self::RELATION_MANY_TO_MANY:
-                    $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                    if ($id !== $actualNewKey) {
-                        $renameIndex($junction, $id, $actualNewKey);
-                        $indexRenamesCompleted[] = [$junction, $actualNewKey, $id];
-                    }
-                    if ($oldTwoWayKey !== $actualNewTwoWayKey) {
-                        $renameIndex($junction, $oldTwoWayKey, $actualNewTwoWayKey);
-                        $indexRenamesCompleted[] = [$junction, $actualNewTwoWayKey, $oldTwoWayKey];
-                    }
-                    break;
-                default:
-                    throw new RelationshipException('Invalid relationship type.');
-            }
-        } catch (\Throwable $e) {
-            // Reverse completed index renames
-            foreach (\array_reverse($indexRenamesCompleted) as [$coll, $from, $to]) {
-                try {
-                    $renameIndex($coll, $from, $to);
-                } catch (\Throwable) {
-                    // Best effort
-                }
-            }
-
-            // Reverse attribute metadata
-            try {
-                $this->updateAttributeMeta($collection->getId(), $actualNewKey, function ($attribute) use ($id, $oldAttribute) {
-                    $attribute->setAttribute('$id', $id);
-                    $attribute->setAttribute('key', $id);
-                    $attribute->setAttribute('options', $oldAttribute['options']);
-                });
-            } catch (\Throwable) {
-                // Best effort
-            }
-
-            try {
-                $this->updateAttributeMeta($relatedCollection->getId(), $actualNewTwoWayKey, function ($twoWayAttribute) use ($oldTwoWayKey, $id, $oldAttribute) {
-                    $options = $twoWayAttribute->getAttribute('options', []);
-                    $options['twoWayKey'] = $id;
-                    $options['twoWay'] = $oldAttribute['options']['twoWay'];
-                    $options['onDelete'] = $oldAttribute['options']['onDelete'];
-                    $twoWayAttribute->setAttribute('$id', $oldTwoWayKey);
-                    $twoWayAttribute->setAttribute('key', $oldTwoWayKey);
-                    $twoWayAttribute->setAttribute('options', $options);
-                });
-            } catch (\Throwable) {
-                // Best effort
-            }
-
-            if ($type === self::RELATION_MANY_TO_MANY) {
-                $junctionId = $this->getJunctionCollection($collection, $relatedCollection, $side);
-                try {
-                    $this->updateAttributeMeta($junctionId, $actualNewKey, function ($attr) use ($id) {
-                        $attr->setAttribute('$id', $id);
-                        $attr->setAttribute('key', $id);
-                    });
-                } catch (\Throwable) {
-                    // Best effort
-                }
-                try {
-                    $this->updateAttributeMeta($junctionId, $actualNewTwoWayKey, function ($attr) use ($oldTwoWayKey) {
-                        $attr->setAttribute('$id', $oldTwoWayKey);
-                        $attr->setAttribute('key', $oldTwoWayKey);
-                    });
-                } catch (\Throwable) {
-                    // Best effort
-                }
-            }
-
-            // Reverse adapter update
-            if ($adapterUpdated) {
-                try {
-                    $this->adapter->updateRelationship(
-                        $collection->getId(),
-                        $relatedCollection->getId(),
-                        $type,
-                        $oldAttribute['options']['twoWay'],
-                        $actualNewKey,
-                        $actualNewTwoWayKey,
-                        $side,
-                        $id,
-                        $oldTwoWayKey
-                    );
-                } catch (\Throwable) {
-                    // Best effort
-                }
-            }
-
-            throw new DatabaseException("Failed to update relationship indexes for '{$id}': " . $e->getMessage(), previous: $e);
-        }
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-        $this->withRetries(fn () => $this->purgeCachedCollection($relatedCollection->getId()));
-
-        return true;
-    }
-
-    /**
-     * Delete a relationship attribute
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws StructureException
-     */
-    public function deleteRelationship(string $collection, string $id): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        $attributes = $collection->getAttribute('attributes', []);
-        $relationship = null;
-
-        foreach ($attributes as $name => $attribute) {
-            if ($attribute['$id'] === $id) {
-                $relationship = $attribute;
-                unset($attributes[$name]);
-                break;
-            }
-        }
-
-        if (\is_null($relationship)) {
-            throw new NotFoundException('Relationship not found');
-        }
-
-        $collection->setAttribute('attributes', \array_values($attributes));
-
-        $relatedCollection = $relationship['options']['relatedCollection'];
-        $type = $relationship['options']['relationType'];
-        $twoWay = $relationship['options']['twoWay'];
-        $twoWayKey = $relationship['options']['twoWayKey'];
-        $side = $relationship['options']['side'];
-
-        $relatedCollection = $this->silent(fn () => $this->getCollection($relatedCollection));
-        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
-
-        foreach ($relatedAttributes as $name => $attribute) {
-            if ($attribute['$id'] === $twoWayKey) {
-                unset($relatedAttributes[$name]);
-                break;
-            }
-        }
-
-        $relatedCollection->setAttribute('attributes', \array_values($relatedAttributes));
-
-        $collectionAttributes = $collection->getAttribute('attributes');
-        $relatedCollectionAttributes = $relatedCollection->getAttribute('attributes');
-
-        // Delete indexes BEFORE dropping columns to avoid referencing non-existent columns
-        // Track deleted indexes for rollback
-        $deletedIndexes = [];
-        $deletedJunction = null;
-
-        $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $side, &$deletedIndexes, &$deletedJunction) {
-            $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);
-                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => self::INDEX_UNIQUE, 'attributes' => [$id]];
-                        if ($twoWay) {
-                            $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                            $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => self::INDEX_UNIQUE, 'attributes' => [$twoWayKey]];
-                        }
-                    }
-                    if ($side === Database::RELATION_SIDE_CHILD) {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => self::INDEX_UNIQUE, 'attributes' => [$twoWayKey]];
-                        if ($twoWay) {
-                            $this->deleteIndex($collection->getId(), $indexKey);
-                            $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => self::INDEX_UNIQUE, 'attributes' => [$id]];
-                        }
-                    }
-                    break;
-                case self::RELATION_ONE_TO_MANY:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => self::INDEX_KEY, 'attributes' => [$twoWayKey]];
-                    } else {
-                        $this->deleteIndex($collection->getId(), $indexKey);
-                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => self::INDEX_KEY, 'attributes' => [$id]];
-                    }
-                    break;
-                case self::RELATION_MANY_TO_ONE:
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteIndex($collection->getId(), $indexKey);
-                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => self::INDEX_KEY, 'attributes' => [$id]];
-                    } else {
-                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
-                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => self::INDEX_KEY, 'attributes' => [$twoWayKey]];
-                    }
-                    break;
-                case self::RELATION_MANY_TO_MANY:
-                    $junction = $this->getJunctionCollection(
-                        $collection,
-                        $relatedCollection,
-                        $side
-                    );
-
-                    $deletedJunction = $this->silent(fn () => $this->getDocument(self::METADATA, $junction));
-                    $this->deleteDocument(self::METADATA, $junction);
-                    break;
-                default:
-                    throw new RelationshipException('Invalid relationship type.');
-            }
-        });
-
-        $collection = $this->silent(fn () => $this->getCollection($collection->getId()));
-        $relatedCollection = $this->silent(fn () => $this->getCollection($relatedCollection->getId()));
-        $collection->setAttribute('attributes', $collectionAttributes);
-        $relatedCollection->setAttribute('attributes', $relatedCollectionAttributes);
-
-        $shouldRollback = false;
-        try {
-            $deleted = $this->adapter->deleteRelationship(
-                $collection->getId(),
-                $relatedCollection->getId(),
-                $type,
-                $twoWay,
-                $id,
-                $twoWayKey,
-                $side
-            );
-
-            if (!$deleted) {
-                throw new DatabaseException('Failed to delete relationship');
-            }
-            $shouldRollback = true;
-        } catch (NotFoundException) {
-            // Ignore — relationship already absent from schema
-        }
-
-        try {
-            $this->withRetries(function () use ($collection, $relatedCollection) {
-                $this->silent(function () use ($collection, $relatedCollection) {
-                    $this->withTransaction(function () use ($collection, $relatedCollection) {
-                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
-                        $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
-                    });
-                });
-            });
-        } catch (\Throwable $e) {
-            if ($shouldRollback) {
-                // Recreate relationship columns
-                try {
-                    $this->adapter->createRelationship(
-                        $collection->getId(),
-                        $relatedCollection->getId(),
-                        $type,
-                        $twoWay,
-                        $id,
-                        $twoWayKey
-                    );
-                } catch (\Throwable) {
-                    // Silent rollback — best effort to restore consistency
-                }
-            }
-
-            // Restore deleted indexes
-            foreach ($deletedIndexes as $indexInfo) {
-                try {
-                    $this->createIndex(
-                        $indexInfo['collection'],
-                        $indexInfo['key'],
-                        $indexInfo['type'],
-                        $indexInfo['attributes']
-                    );
-                } catch (\Throwable) {
-                    // Silent rollback — best effort
-                }
-            }
-
-            // Restore junction collection metadata for M2M
-            if ($deletedJunction !== null && !$deletedJunction->isEmpty()) {
-                try {
-                    $this->silent(fn () => $this->createDocument(self::METADATA, $deletedJunction));
-                } catch (\Throwable) {
-                    // Silent rollback — best effort
-                }
-            }
-
-            throw new DatabaseException(
-                "Failed to persist metadata after retries for relationship deletion '{$id}': " . $e->getMessage(),
-                previous: $e
-            );
-        }
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-        $this->withRetries(fn () => $this->purgeCachedCollection($relatedCollection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_ATTRIBUTE_DELETE, $relationship);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Rename Index
-     *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     *
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws StructureException
-     */
-    public function renameIndex(string $collection, string $old, string $new): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $index = \in_array($old, \array_map(fn ($index) => $index['$id'], $indexes));
-
-        if ($index === false) {
-            throw new NotFoundException('Index not found');
-        }
-
-        $indexNew = \in_array($new, \array_map(fn ($index) => $index['$id'], $indexes));
-
-        if ($indexNew !== false) {
-            throw new DuplicateException('Index name already used');
-        }
-
-        foreach ($indexes as $key => $value) {
-            if (isset($value['$id']) && $value['$id'] === $old) {
-                $indexes[$key]['key'] = $new;
-                $indexes[$key]['$id'] = $new;
-                $indexNew = $indexes[$key];
-                break;
-            }
-        }
-
-        $collection->setAttribute('indexes', $indexes);
-
-        $renamed = false;
-        try {
-            $renamed = $this->adapter->renameIndex($collection->getId(), $old, $new);
-            if (!$renamed) {
-                throw new DatabaseException('Failed to rename index');
-            }
-        } catch (\Throwable $e) {
-            // Check if the rename already happened in schema (orphan from prior
-            // partial failure where rename succeeded but metadata update and
-            // rollback both failed). Verify by attempting a reverse rename — if
-            // $new exists in schema, the reverse succeeds confirming a prior rename.
-            try {
-                $this->adapter->renameIndex($collection->getId(), $new, $old);
-                // Reverse succeeded — index was at $new. Re-rename to complete.
-                $renamed = $this->adapter->renameIndex($collection->getId(), $old, $new);
-            } catch (\Throwable) {
-                // Reverse also failed — genuine error
-                throw new DatabaseException("Failed to rename index '{$old}' to '{$new}': " . $e->getMessage(), previous: $e);
-            }
-        }
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->adapter->renameIndex($collection->getId(), $new, $old),
-            shouldRollback: $renamed,
-            operationDescription: "index rename '{$old}' to '{$new}'"
-        );
-
-        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
-
-        try {
-            $this->trigger(self::EVENT_INDEX_RENAME, $indexNew);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * Create Index
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param array<string> $attributes
-     * @param array<int> $lengths
-     * @param array<string> $orders
-     * @param int $ttl
-     *
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws StructureException
-     * @throws Exception
-     */
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths = [], array $orders = [], int $ttl = 1): bool
-    {
-        if (empty($attributes)) {
-            throw new DatabaseException('Missing attributes');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        // index IDs are case-insensitive
-        $indexes = $collection->getAttribute('indexes', []);
-
-        /** @var array<Document> $indexes */
-        foreach ($indexes as $index) {
-            if (\strtolower($index->getId()) === \strtolower($id)) {
-                throw new DuplicateException('Index already exists');
-            }
-        }
-
-        if ($this->adapter->getCountOfIndexes($collection) >= $this->adapter->getLimitForIndexes()) {
-            throw new LimitException('Index limit reached. Cannot create new index.');
-        }
-
-        /** @var array<Document> $collectionAttributes */
-        $collectionAttributes = $collection->getAttribute('attributes', []);
-        $indexAttributesWithTypes = [];
-        foreach ($attributes as $i => $attr) {
-            // Support nested paths on object attributes using dot notation:
-            // attribute.key.nestedKey -> base attribute "attribute"
-            $baseAttr = $attr;
-            if (\str_contains($attr, '.')) {
-                $baseAttr = \explode('.', $attr, 2)[0] ?? $attr;
-            }
-
-            foreach ($collectionAttributes as $collectionAttribute) {
-                if ($collectionAttribute->getAttribute('key') === $baseAttr) {
-
-                    $attributeType = $collectionAttribute->getAttribute('type');
-                    $indexAttributesWithTypes[$attr] = $attributeType;
-
-                    /**
-                     * mysql does not save length in collection when length = attributes size
-                     */
-                    if (in_array($attributeType, self::STRING_TYPES)) {
-                        if (!empty($lengths[$i]) && $lengths[$i] === $collectionAttribute->getAttribute('size') && $this->adapter->getMaxIndexLength() > 0) {
-                            $lengths[$i] = null;
-                        }
-                    }
-
-                    $isArray = $collectionAttribute->getAttribute('array', false);
-                    if ($isArray) {
-                        if ($this->adapter->getMaxIndexLength() > 0) {
-                            $lengths[$i] = self::MAX_ARRAY_INDEX_LENGTH;
-                        }
-                        $orders[$i] = null;
-                    }
-                    break;
-                }
-            }
-        }
-
-        $index = new Document([
-            '$id' => ID::custom($id),
-            'key' => $id,
-            'type' => $type,
-            'attributes' => $attributes,
-            'lengths' => $lengths,
-            'orders' => $orders,
-            'ttl' => $ttl
-        ]);
-
-        if ($this->validate) {
-
-            $validator = new IndexValidator(
-                $collection->getAttribute('attributes', []),
-                $collection->getAttribute('indexes', []),
-                $this->adapter->getMaxIndexLength(),
-                $this->adapter->getInternalIndexesKeys(),
-                $this->adapter->getSupportForIndexArray(),
-                $this->adapter->getSupportForSpatialIndexNull(),
-                $this->adapter->getSupportForSpatialIndexOrder(),
-                $this->adapter->getSupportForVectors(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForMultipleFulltextIndexes(),
-                $this->adapter->getSupportForIdenticalIndexes(),
-                $this->adapter->getSupportForObjectIndexes(),
-                $this->adapter->getSupportForTrigramIndex(),
-                $this->adapter->getSupportForSpatialAttributes(),
-                $this->adapter->getSupportForIndex(),
-                $this->adapter->getSupportForUniqueIndex(),
-                $this->adapter->getSupportForFulltextIndex(),
-                $this->adapter->getSupportForTTLIndexes(),
-                $this->adapter->getSupportForObject()
-            );
-            if (!$validator->isValid($index)) {
-                throw new IndexException($validator->getDescription());
-            }
-        }
-
-        $created = false;
-        $existsInSchema = false;
-
-        if ($this->adapter->getSupportForSchemaIndexes()
-            && !($this->adapter->getSharedTables() && $this->isMigrating())) {
-            $schemaIndexes = $this->getSchemaIndexes($collection->getId());
-            $filteredId = $this->adapter->filter($id);
-
-            foreach ($schemaIndexes as $schemaIndex) {
-                if (\strtolower($schemaIndex->getId()) === \strtolower($filteredId)) {
-                    $schemaColumns = $schemaIndex->getAttribute('columns', []);
-                    $schemaLengths = $schemaIndex->getAttribute('lengths', []);
-
-                    $filteredAttributes = \array_map(fn ($a) => $this->adapter->filter($a), $attributes);
-                    $match = ($schemaColumns === $filteredAttributes && $schemaLengths === $lengths);
-
-                    if ($match) {
-                        $existsInSchema = true;
-                    } else {
-                        // Orphan index with wrong definition — drop so it
-                        // gets recreated with the correct shape.
-                        try {
-                            $this->adapter->deleteIndex($collection->getId(), $id);
-                        } catch (NotFoundException) {
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-
-        if (!$existsInSchema) {
-            try {
-                $created = $this->adapter->createIndex($collection->getId(), $id, $type, $attributes, $lengths, $orders, $indexAttributesWithTypes, [], $ttl);
-
-                if (!$created) {
-                    throw new DatabaseException('Failed to create index');
-                }
-            } catch (DuplicateException) {
-                // Metadata check (lines above) already verified index is absent
-                // from metadata. A DuplicateException from the adapter means the
-                // index exists only in physical schema — an orphan from a prior
-                // partial failure. Skip creation and proceed to metadata update.
-            }
-        }
-
-        $collection->setAttribute('indexes', $index, Document::SET_TYPE_APPEND);
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->cleanupIndex($collection->getId(), $id),
-            shouldRollback: $created,
-            operationDescription: "index creation '{$id}'"
-        );
-
-        $this->trigger(self::EVENT_INDEX_CREATE, $index);
-
-        return true;
-    }
-
-    /**
-     * Delete Index
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws StructureException
-     */
-    public function deleteIndex(string $collection, string $id): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $indexDeleted = null;
-        foreach ($indexes as $key => $value) {
-            if (isset($value['$id']) && $value['$id'] === $id) {
-                $indexDeleted = $value;
-                unset($indexes[$key]);
-            }
-        }
-
-        if (\is_null($indexDeleted)) {
-            throw new NotFoundException('Index not found');
-        }
-
-        $shouldRollback = false;
-        $deleted = false;
-        try {
-            $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
-
-            if (!$deleted) {
-                throw new DatabaseException('Failed to delete index');
-            }
-            $shouldRollback = true;
-        } catch (NotFoundException) {
-            // Index already absent from schema; treat as deleted
-            $deleted = true;
-        }
-
-        $collection->setAttribute('indexes', \array_values($indexes));
-
-        // Build indexAttributeTypes from collection attributes for rollback
-        /** @var array<Document> $collectionAttributes */
-        $collectionAttributes = $collection->getAttribute('attributes', []);
-        $indexAttributeTypes = [];
-        foreach ($indexDeleted->getAttribute('attributes', []) as $attr) {
-            $baseAttr = \str_contains($attr, '.') ? \explode('.', $attr, 2)[0] : $attr;
-            foreach ($collectionAttributes as $collectionAttribute) {
-                if ($collectionAttribute->getAttribute('key') === $baseAttr) {
-                    $indexAttributeTypes[$attr] = $collectionAttribute->getAttribute('type');
-                    break;
-                }
-            }
-        }
-
-        $this->updateMetadata(
-            collection: $collection,
-            rollbackOperation: fn () => $this->adapter->createIndex(
-                $collection->getId(),
-                $id,
-                $indexDeleted->getAttribute('type'),
-                $indexDeleted->getAttribute('attributes', []),
-                $indexDeleted->getAttribute('lengths', []),
-                $indexDeleted->getAttribute('orders', []),
-                $indexAttributeTypes,
-                [],
-                $indexDeleted->getAttribute('ttl', 1)
-            ),
-            shouldRollback: $shouldRollback,
-            operationDescription: "index deletion '{$id}'",
-            silentRollback: true
-        );
-
-
-        try {
-            $this->trigger(self::EVENT_INDEX_DELETE, $indexDeleted);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $deleted;
-    }
-
-    /**
-     * Get Document
-     *
-     * @param string $collection
-     * @param string $id
-     * @param Query[] $queries
-     * @param bool $forUpdate
-     * @return Document
-     * @throws NotFoundException
-     * @throws QueryException
-     * @throws Exception
-     */
-    public function getDocument(string $collection, string $id, array $queries = [], bool $forUpdate = false): Document
-    {
-        if ($collection === self::METADATA && $id === self::METADATA) {
-            return new Document(self::COLLECTION);
-        }
-
-        if (empty($collection)) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        if (empty($id)) {
-            return new Document();
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentValidator($attributes, $this->adapter->getSupportForAttributes());
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
-        }
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
-        );
-
-        $selects = Query::groupByType($queries)['selections'];
-        $selections = $this->validateSelections($collection, $selects);
-        $nestedSelections = $this->processRelationshipQueries($relationships, $queries);
-
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-
-        [$collectionKey, $documentKey, $hashKey] = $this->getCacheKeys(
-            $collection->getId(),
-            $id,
-            $selections
-        );
-
-        // A locking read must observe the current row, not a cached copy:
-        // updateDocument merges the changes into this read and writes the result
-        // back, so serving it from a stale cache would persist the staleness.
-        $cached = null;
-        if (!$forUpdate) {
-            try {
-                $cached = $this->cache->load($documentKey, self::TTL, $hashKey);
-            } catch (Exception $e) {
-                Console::warning('Warning: Failed to get document from cache: ' . $e->getMessage());
-            }
-        }
-
-        // Negative cache hit
-        if (\is_array($cached) && isset($cached[self::CACHE_EMPTY_MARKER])) {
-            return $this->createDocumentInstance($collection->getId(), []);
-        }
-
-        if ($cached) {
-            $document = $this->createDocumentInstance($collection->getId(), $cached);
-
-            // JSON serialization in cache backends collapses floats with zero
-            // fractions to ints. Re-cast so cached and freshly-loaded documents
-            // compare equal under strict equality (e.g. in updateDocument).
-            $document = $this->casting($collection, $document);
-
-            if ($collection->getId() !== self::METADATA) {
-
-                if (!$this->authorization->isValid(new Input(self::PERMISSION_READ, [
-                    ...$collection->getRead(),
-                    ...($documentSecurity ? $document->getRead() : [])
-                ]))) {
-                    return $this->createDocumentInstance($collection->getId(), []);
-                }
-            }
-
-            $this->trigger(self::EVENT_DOCUMENT_READ, $document);
-
-            if ($this->isTtlExpired($collection, $document)) {
-                return $this->createDocumentInstance($collection->getId(), []);
-            }
-
-            return $document;
-        }
-
-        // Capture the generation before reading: if a concurrent purge advances
-        // it, saveWithLease() below rejects this now-stale value. '0' means no lease.
-        $generation = '0';
-        if (!$forUpdate) {
-            try {
-                $generation = $this->cache->getGeneration($documentKey);
-            } catch (Exception $e) {
-                Console::warning('Warning: Failed to get cache generation: ' . $e->getMessage());
-            }
-        }
-
-        $document = $this->adapter->getDocument(
-            $collection,
-            $id,
-            $queries,
-            $forUpdate
-        );
-
-        if ($document->isEmpty()) {
-            if (!$forUpdate && empty($relationships)) {
-                try {
-                    $marker = [self::CACHE_EMPTY_MARKER => true];
-
-                    if ($this->cache->saveWithLease($documentKey, $marker, $hashKey, $generation) !== false) {
-                        $this->cache->save($collectionKey, 'empty', $documentKey);
-                    }
-                } catch (Exception $e) {
-                    Console::warning('Failed to save empty document to cache: ' . $e->getMessage());
-                }
-            }
-
-            return $this->createDocumentInstance($collection->getId(), []);
-        }
-
-        if ($this->isTtlExpired($collection, $document)) {
-            return $this->createDocumentInstance($collection->getId(), []);
-        }
-
-        $document = $this->adapter->castingAfter($collection, $document);
-
-        // Convert to custom document type if mapped
-        if (isset($this->documentTypes[$collection->getId()])) {
-            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
-        }
-
-        $document->setAttribute('$collection', $collection->getId());
-
-        if ($collection->getId() !== self::METADATA) {
-            if (!$this->authorization->isValid(new Input(self::PERMISSION_READ, [
-                ...$collection->getRead(),
-                ...($documentSecurity ? $document->getRead() : [])
-            ]))) {
-                return $this->createDocumentInstance($collection->getId(), []);
-            }
-        }
-
-        $document = $this->casting($collection, $document);
-        $document = $this->decode($collection, $document, $selections);
-
-        // Skip relationship population if we're in batch mode (relationships will be populated later)
-        if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships && !empty($relationships) && (empty($selects) || !empty($nestedSelections))) {
-            $documents = $this->silent(fn () => $this->populateDocumentsRelationships([$document], $collection, $this->relationshipFetchDepth, $nestedSelections));
-            $document = $documents[0];
-        }
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn ($attribute) => $attribute['type'] === Database::VAR_RELATIONSHIP
-        );
-
-        // Don't save to cache if it's part of a relationship, or if this is a
-        // locking read: a forUpdate read happens inside an open transaction, and
-        // caching the pre-commit row would poison the cache for other readers.
-        if (!$forUpdate && empty($relationships)) {
-            try {
-                // Index for invalidation only when the value was actually cached.
-                if ($this->cache->saveWithLease($documentKey, $document->getArrayCopy(), $hashKey, $generation) !== false) {
-                    $this->cache->save($collectionKey, 'empty', $documentKey);
-                }
-            } catch (Exception $e) {
-                Console::warning('Failed to save document to cache: ' . $e->getMessage());
-            }
-        }
-
-        $this->trigger(self::EVENT_DOCUMENT_READ, $document);
-
-        return $document;
-    }
-
-    private function isTtlExpired(Document $collection, Document $document): bool
-    {
-        if (!$this->adapter->getSupportForTTLIndexes()) {
-            return false;
-        }
-        foreach ($collection->getAttribute('indexes', []) as $index) {
-            if ($index->getAttribute('type') !== self::INDEX_TTL) {
-                continue;
-            }
-            $ttlSeconds = (int) $index->getAttribute('ttl', 0);
-            $ttlAttr    = $index->getAttribute('attributes')[0] ?? null;
-            if ($ttlSeconds <= 0 || !$ttlAttr) {
-                return false;
-            }
-            $val = $document->getAttribute($ttlAttr);
-            if (is_string($val)) {
-                try {
-                    $start = new \DateTime($val);
-                    return (new \DateTime()) > (clone $start)->modify("+{$ttlSeconds} seconds");
-                } catch (\Throwable) {
-                    return false;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Populate relationships for an array of documents with breadth-first traversal
-     *
-     * @param array<Document> $documents
-     * @param Document $collection
-     * @param int $relationshipFetchDepth
-     * @param array<string, array<Query>> $selects
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateDocumentsRelationships(
-        array $documents,
-        Document $collection,
-        int $relationshipFetchDepth = 0,
-        array $selects = []
-    ): array {
-        // Prevent nested relationship population during fetches
-        $this->inBatchRelationshipPopulation = true;
-
-        try {
-            $queue = [
-                [
-                    'documents' => $documents,
-                    'collection' => $collection,
-                    'depth' => $relationshipFetchDepth,
-                    'selects' => $selects,
-                    'skipKey' => null, // No back-reference to skip at top level
-                    'hasExplicitSelects' => !empty($selects) // Track if we're in explicit select mode
-                ]
-            ];
-
-            $currentDepth = $relationshipFetchDepth;
-
-            while (!empty($queue) && $currentDepth < self::RELATION_MAX_DEPTH) {
-                $nextQueue = [];
-
-                foreach ($queue as $item) {
-                    $docs = $item['documents'];
-                    $coll = $item['collection'];
-                    $sels = $item['selects'];
-                    $skipKey = $item['skipKey'] ?? null;
-                    $parentHasExplicitSelects = $item['hasExplicitSelects'];
-
-                    if (empty($docs)) {
-                        continue;
-                    }
-
-                    $attributes = $coll->getAttribute('attributes', []);
-                    $relationships = [];
-
-                    foreach ($attributes as $attribute) {
-                        if ($attribute['type'] === Database::VAR_RELATIONSHIP) {
-                            // Skip the back-reference relationship that brought us here
-                            if ($attribute['key'] === $skipKey) {
-                                continue;
-                            }
-
-                            // Include relationship if:
-                            // 1. No explicit selects (fetch all) OR
-                            // 2. Relationship is explicitly selected
-                            if (!$parentHasExplicitSelects || \array_key_exists($attribute['key'], $sels)) {
-                                $relationships[] = $attribute;
-                            }
-                        }
-                    }
-
-                    foreach ($relationships as $relationship) {
-                        $key = $relationship['key'];
-                        $queries = $sels[$key] ?? [];
-                        $relationship->setAttribute('collection', $coll->getId());
-                        $isAtMaxDepth = ($currentDepth + 1) >= self::RELATION_MAX_DEPTH;
-
-                        // If we're at max depth, remove this relationship from source documents and skip
-                        if ($isAtMaxDepth) {
-                            foreach ($docs as $doc) {
-                                $doc->removeAttribute($key);
-                            }
-                            continue;
-                        }
-
-                        $relatedDocs = $this->populateSingleRelationshipBatch(
-                            $docs,
-                            $relationship,
-                            $queries
-                        );
-
-                        // Get two-way relationship info
-                        $twoWay = $relationship['options']['twoWay'];
-                        $twoWayKey = $relationship['options']['twoWayKey'];
-
-                        // Queue if:
-                        // 1. No explicit selects (fetch all recursively), OR
-                        // 2. Explicit nested selects for this relationship
-                        $hasNestedSelectsForThisRel = isset($sels[$key]);
-                        $shouldQueue = !empty($relatedDocs) &&
-                            ($hasNestedSelectsForThisRel || !$parentHasExplicitSelects);
-
-                        if ($shouldQueue) {
-                            $relatedCollectionId = $relationship['options']['relatedCollection'];
-                            $relatedCollection = $this->silent(fn () => $this->getCollection($relatedCollectionId));
-
-                            if (!$relatedCollection->isEmpty()) {
-                                // Get nested selections for this relationship
-                                $relationshipQueries = $hasNestedSelectsForThisRel ? $sels[$key] : [];
-
-                                // Extract nested selections for the related collection
-                                $relatedCollectionRelationships = $relatedCollection->getAttribute('attributes', []);
-                                $relatedCollectionRelationships = \array_filter(
-                                    $relatedCollectionRelationships,
-                                    fn ($attr) => $attr['type'] === Database::VAR_RELATIONSHIP
-                                );
-
-                                $nextSelects = $this->processRelationshipQueries($relatedCollectionRelationships, $relationshipQueries);
-
-                                // If parent has explicit selects, child inherits that mode
-                                // (even if nextSelects is empty, we're still in explicit mode)
-                                $childHasExplicitSelects = $parentHasExplicitSelects;
-
-                                $nextQueue[] = [
-                                    'documents' => $relatedDocs,
-                                    'collection' => $relatedCollection,
-                                    'depth' => $currentDepth + 1,
-                                    'selects' => $nextSelects,
-                                    'skipKey' => $twoWay ? $twoWayKey : null, // Skip the back-reference at next depth
-                                    'hasExplicitSelects' => $childHasExplicitSelects
-                                ];
-                            }
-                        }
-
-                        // Remove back-references for two-way relationships
-                        // Back-references are always removed to prevent circular references
-                        if ($twoWay && !empty($relatedDocs)) {
-                            foreach ($relatedDocs as $relatedDoc) {
-                                $relatedDoc->removeAttribute($twoWayKey);
-                            }
-                        }
-                    }
-                }
-
-                $queue = $nextQueue;
-                $currentDepth++;
-            }
-        } finally {
-            $this->inBatchRelationshipPopulation = false;
-        }
-
-        return $documents;
-    }
-
-    /**
-     * Populate a single relationship type for all documents in batch
-     * Returns all related documents that were populated
-     *
-     * @param array<Document> $documents
-     * @param Document $relationship
-     * @param array<Query> $queries
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateSingleRelationshipBatch(
-        array $documents,
-        Document $relationship,
-        array $queries
-    ): array {
-        return match ($relationship['options']['relationType']) {
-            Database::RELATION_ONE_TO_ONE => $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries),
-            Database::RELATION_ONE_TO_MANY => $this->populateOneToManyRelationshipsBatch($documents, $relationship, $queries),
-            Database::RELATION_MANY_TO_ONE => $this->populateManyToOneRelationshipsBatch($documents, $relationship, $queries),
-            Database::RELATION_MANY_TO_MANY => $this->populateManyToManyRelationshipsBatch($documents, $relationship, $queries),
-            default => [],
-        };
-    }
-
-    /**
-     * Populate one-to-one relationships in batch
-     * Returns all related documents that were fetched
-     *
-     * @param array<Document> $documents
-     * @param Document $relationship
-     * @param array<Query> $queries
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateOneToOneRelationshipsBatch(array $documents, Document $relationship, array $queries): array
-    {
-        $key = $relationship['key'];
-        $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-
-        $relatedIds = [];
-        $documentsByRelatedId = [];
-
-        foreach ($documents as $document) {
-            $value = $document->getAttribute($key);
-            if (!\is_null($value)) {
-                // Skip if value is already populated
-                if ($value instanceof Document) {
-                    continue;
-                }
-
-                // For one-to-one, multiple documents can reference the same related ID
-                $relatedIds[] = $value;
-                if (!isset($documentsByRelatedId[$value])) {
-                    $documentsByRelatedId[$value] = [];
-                }
-                $documentsByRelatedId[$value][] = $document;
-            }
-        }
-
-        if (empty($relatedIds)) {
-            return [];
-        }
-
-        $uniqueRelatedIds = \array_unique($relatedIds);
-        $relatedDocuments = [];
-
-        // Process in chunks to avoid exceeding query value limits
-        foreach (\array_chunk($uniqueRelatedIds, self::RELATION_QUERY_CHUNK_SIZE) as $chunk) {
-            $chunkDocs = $this->find($relatedCollection->getId(), [
-                Query::equal('$id', $chunk),
-                Query::limit(PHP_INT_MAX),
-                ...$queries
-            ]);
-            \array_push($relatedDocuments, ...$chunkDocs);
-        }
-
-        // Index related documents by ID for quick lookup
-        $relatedById = [];
-        foreach ($relatedDocuments as $related) {
-            $relatedById[$related->getId()] = $related;
-        }
-
-        // Assign related documents to their parent documents
-        foreach ($documentsByRelatedId as $relatedId => $docs) {
-            if (isset($relatedById[$relatedId])) {
-                // Set the relationship for all documents that reference this related ID
-                foreach ($docs as $document) {
-                    $document->setAttribute($key, $relatedById[$relatedId]);
-                }
-            } else {
-                // If related document not found, set to empty Document instead of leaving the string ID
-                foreach ($docs as $document) {
-                    $document->setAttribute($key, new Document());
-                }
-            }
-        }
-
-        return $relatedDocuments;
-    }
-
-    /**
-     * Populate one-to-many relationships in batch
-     * Returns all related documents that were fetched
-     *
-     * @param array<Document> $documents
-     * @param Document $relationship
-     * @param array<Query> $queries
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateOneToManyRelationshipsBatch(
-        array $documents,
-        Document $relationship,
-        array $queries,
-    ): array {
-        $key = $relationship['key'];
-        $twoWay = $relationship['options']['twoWay'];
-        $twoWayKey = $relationship['options']['twoWayKey'];
-        $side = $relationship['options']['side'];
-        $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-
-        if ($side === Database::RELATION_SIDE_CHILD) {
-            // Child side - treat like one-to-one
-            if (!$twoWay) {
-                foreach ($documents as $document) {
-                    $document->removeAttribute($key);
-                }
-                return [];
-            }
-            return $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries);
-        }
-
-        // Parent side - fetch multiple related documents
-        $parentIds = [];
-        foreach ($documents as $document) {
-            $parentId = $document->getId();
-            $parentIds[] = $parentId;
-        }
-
-        $parentIds = \array_unique($parentIds);
-
-        if (empty($parentIds)) {
-            return [];
-        }
-
-        // For batch relationship population, we need to fetch documents with all attributes
-        // to enable proper grouping by back-reference, then apply selects afterward
-        $selectQueries = [];
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                $selectQueries[] = $query;
-            } else {
-                $otherQueries[] = $query;
-            }
-        }
-
-        $relatedDocuments = [];
-
-        foreach (\array_chunk($parentIds, self::RELATION_QUERY_CHUNK_SIZE) as $chunk) {
-            $chunkDocs = $this->find($relatedCollection->getId(), [
-                Query::equal($twoWayKey, $chunk),
-                Query::limit(PHP_INT_MAX),
-                ...$otherQueries
-            ]);
-            \array_push($relatedDocuments, ...$chunkDocs);
-        }
-
-        // Group related documents by parent ID
-        $relatedByParentId = [];
-        foreach ($relatedDocuments as $related) {
-            $parentId = $related->getAttribute($twoWayKey);
-            if (!\is_null($parentId)) {
-                // Handle case where parentId might be a Document object instead of string
-                $parentKey = $parentId instanceof Document
-                    ? $parentId->getId()
-                    : $parentId;
-
-                if (!isset($relatedByParentId[$parentKey])) {
-                    $relatedByParentId[$parentKey] = [];
-                }
-                // We don't remove the back-reference here because documents may be reused across fetches
-                // Cycles are prevented by depth limiting in breadth-first traversal
-                $relatedByParentId[$parentKey][] = $related;
-            }
-        }
-
-        $this->applySelectFiltersToDocuments($relatedDocuments, $selectQueries);
-
-        // Assign related documents to their parent documents
-        foreach ($documents as $document) {
-            $parentId = $document->getId();
-            $relatedDocs = $relatedByParentId[$parentId] ?? [];
-            $document->setAttribute($key, $relatedDocs);
-        }
-
-        return $relatedDocuments;
-    }
-
-    /**
-     * Populate many-to-one relationships in batch
-     *
-     * @param array<Document> $documents
-     * @param Document $relationship
-     * @param array<Query> $queries
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateManyToOneRelationshipsBatch(
-        array $documents,
-        Document $relationship,
-        array $queries,
-    ): array {
-        $key = $relationship['key'];
-        $twoWay = $relationship['options']['twoWay'];
-        $twoWayKey = $relationship['options']['twoWayKey'];
-        $side = $relationship['options']['side'];
-        $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-
-        if ($side === Database::RELATION_SIDE_PARENT) {
-            // Parent side - treat like one-to-one
-            return $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries);
-        }
-
-        // Child side - fetch multiple related documents
-        if (!$twoWay) {
-            foreach ($documents as $document) {
-                $document->removeAttribute($key);
-            }
-            return [];
-        }
-
-        $childIds = [];
-        foreach ($documents as $document) {
-            $childId = $document->getId();
-            $childIds[] = $childId;
-        }
-
-        $childIds = array_unique($childIds);
-
-        if (empty($childIds)) {
-            return [];
-        }
-
-        $selectQueries = [];
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                $selectQueries[] = $query;
-            } else {
-                $otherQueries[] = $query;
-            }
-        }
-
-        $relatedDocuments = [];
-
-        foreach (\array_chunk($childIds, self::RELATION_QUERY_CHUNK_SIZE) as $chunk) {
-            $chunkDocs = $this->find($relatedCollection->getId(), [
-                Query::equal($twoWayKey, $chunk),
-                Query::limit(PHP_INT_MAX),
-                ...$otherQueries
-            ]);
-            \array_push($relatedDocuments, ...$chunkDocs);
-        }
-
-        // Group related documents by child ID
-        $relatedByChildId = [];
-        foreach ($relatedDocuments as $related) {
-            $childId = $related->getAttribute($twoWayKey);
-            if (!\is_null($childId)) {
-                // Handle case where childId might be a Document object instead of string
-                $childKey = $childId instanceof Document
-                    ? $childId->getId()
-                    : $childId;
-
-                if (!isset($relatedByChildId[$childKey])) {
-                    $relatedByChildId[$childKey] = [];
-                }
-                // We don't remove the back-reference here because documents may be reused across fetches
-                // Cycles are prevented by depth limiting in breadth-first traversal
-                $relatedByChildId[$childKey][] = $related;
-            }
-        }
-
-        $this->applySelectFiltersToDocuments($relatedDocuments, $selectQueries);
-
-        foreach ($documents as $document) {
-            $childId = $document->getId();
-            $document->setAttribute($key, $relatedByChildId[$childId] ?? []);
-        }
-
-        return $relatedDocuments;
-    }
-
-    /**
-     * Populate many-to-many relationships in batch
-     *
-     * @param array<Document> $documents
-     * @param Document $relationship
-     * @param array<Query> $queries
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    private function populateManyToManyRelationshipsBatch(
-        array $documents,
-        Document $relationship,
-        array $queries
-    ): array {
-        $key = $relationship['key'];
-        $twoWay = $relationship['options']['twoWay'];
-        $twoWayKey = $relationship['options']['twoWayKey'];
-        $side = $relationship['options']['side'];
-        $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-        $collection = $this->getCollection($relationship->getAttribute('collection'));
-
-        if (!$twoWay && $side === Database::RELATION_SIDE_CHILD) {
-            return [];
-        }
-
-        $documentIds = [];
-        foreach ($documents as $document) {
-            $documentId = $document->getId();
-            $documentIds[] = $documentId;
-        }
-
-        $documentIds = array_unique($documentIds);
-
-        if (empty($documentIds)) {
-            return [];
-        }
-
-        $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-        $junctions = [];
-
-        foreach (\array_chunk($documentIds, self::RELATION_QUERY_CHUNK_SIZE) as $chunk) {
-            $chunkJunctions = $this->skipRelationships(fn () => $this->find($junction, [
-                Query::equal($twoWayKey, $chunk),
-                Query::limit(PHP_INT_MAX)
-            ]));
-            \array_push($junctions, ...$chunkJunctions);
-        }
-
-        $relatedIds = [];
-        $junctionsByDocumentId = [];
-
-        foreach ($junctions as $junctionDoc) {
-            $documentId = $junctionDoc->getAttribute($twoWayKey);
-            $relatedId = $junctionDoc->getAttribute($key);
-
-            if (!\is_null($documentId) && !\is_null($relatedId)) {
-                if (!isset($junctionsByDocumentId[$documentId])) {
-                    $junctionsByDocumentId[$documentId] = [];
-                }
-                $junctionsByDocumentId[$documentId][] = $relatedId;
-                $relatedIds[] = $relatedId;
-            }
-        }
-
-        $related = [];
-        $allRelatedDocs = [];
-        if (!empty($relatedIds)) {
-            $uniqueRelatedIds = array_unique($relatedIds);
-            $foundRelated = [];
-
-            foreach (\array_chunk($uniqueRelatedIds, self::RELATION_QUERY_CHUNK_SIZE) as $chunk) {
-                $chunkDocs = $this->find($relatedCollection->getId(), [
-                    Query::equal('$id', $chunk),
-                    Query::limit(PHP_INT_MAX),
-                    ...$queries
-                ]);
-                \array_push($foundRelated, ...$chunkDocs);
-            }
-
-            $allRelatedDocs = $foundRelated;
-
-            $relatedById = [];
-            foreach ($foundRelated as $doc) {
-                $relatedById[$doc->getId()] = $doc;
-            }
-
-            // Build final related arrays maintaining junction order
-            foreach ($junctionsByDocumentId as $documentId => $relatedDocIds) {
-                $documentRelated = [];
-                foreach ($relatedDocIds as $relatedId) {
-                    if (isset($relatedById[$relatedId])) {
-                        $documentRelated[] = $relatedById[$relatedId];
-                    }
-                }
-                $related[$documentId] = $documentRelated;
-            }
-        }
-
-        foreach ($documents as $document) {
-            $documentId = $document->getId();
-            $document->setAttribute($key, $related[$documentId] ?? []);
-        }
-
-        return $allRelatedDocs;
-    }
-
-    /**
-     * Apply select filters to documents after fetching
-     *
-     * Filters document attributes based on select queries while preserving internal attributes.
-     * This is used in batch relationship population to apply selects after grouping.
-     *
-     * @param array<Document> $documents Documents to filter
-     * @param array<Query> $selectQueries Select query objects
-     * @return void
-     */
-    private function applySelectFiltersToDocuments(array $documents, array $selectQueries): void
-    {
-        if (empty($selectQueries) || empty($documents)) {
-            return;
-        }
-
-        // Collect all attributes to keep from select queries
-        $attributesToKeep = [];
-        foreach ($selectQueries as $selectQuery) {
-            foreach ($selectQuery->getValues() as $value) {
-                $attributesToKeep[$value] = true;
-            }
-        }
-
-        // Early return if wildcard selector present
-        if (isset($attributesToKeep['*'])) {
-            return;
-        }
-
-        // Always preserve internal attributes (use hashmap for O(1) lookup)
-        $internalKeys = \array_map(fn ($attr) => $attr['$id'], $this->getInternalAttributes());
-        foreach ($internalKeys as $key) {
-            $attributesToKeep[$key] = true;
-        }
-
-        foreach ($documents as $doc) {
-            $allKeys = \array_keys($doc->getArrayCopy());
-            foreach ($allKeys as $attrKey) {
-                // Keep if: explicitly selected OR is internal attribute ($ prefix)
-                if (!isset($attributesToKeep[$attrKey]) && !\str_starts_with($attrKey, '$')) {
-                    $doc->removeAttribute($attrKey);
-                }
-            }
-        }
-    }
-
-    /**
-     * Create Document
-     *
-     * @param string $collection
-     * @param Document $document
-     * @return Document
-     * @throws AuthorizationException
-     * @throws DatabaseException
-     * @throws StructureException
-     */
-    public function createDocument(string $collection, Document $document): Document
-    {
-        if (
-            $collection !== self::METADATA
-            && $this->adapter->getSharedTables()
-            && !$this->adapter->getTenantPerDocument()
-            && empty($this->adapter->getTenant())
-        ) {
-            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
-        }
-
-        if (
-            !$this->adapter->getSharedTables()
-            && $this->adapter->getTenantPerDocument()
-        ) {
-            throw new DatabaseException('Shared tables must be enabled if tenant per document is enabled.');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->getId() !== self::METADATA) {
-            $isValid = $this->authorization->isValid(new Input(self::PERMISSION_CREATE, $collection->getCreate()));
-            if (!$isValid) {
-                throw new AuthorizationException($this->authorization->getDescription());
-            }
-        }
-
-        $time = DateTime::now();
-
-        $createdAt = $document->getCreatedAt();
-        $updatedAt = $document->getUpdatedAt();
-
-        $document
-            ->setAttribute('$id', empty($document->getId()) ? ID::unique() : $document->getId())
-            ->setAttribute('$collection', $collection->getId())
-            ->setAttribute('$createdAt', ($createdAt === null || !$this->preserveDates) ? $time : $createdAt)
-            ->setAttribute('$updatedAt', ($updatedAt === null || !$this->preserveDates) ? $time : $updatedAt);
-
-        if (empty($document->getPermissions())) {
-            $document->setAttribute('$permissions', []);
-        }
-
-        if ($this->adapter->getSharedTables()) {
-            if ($this->adapter->getTenantPerDocument()) {
-                if (
-                    $collection->getId() !== static::METADATA
-                    && $document->getTenant() === null
-                ) {
-                    throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
-                }
-            } else {
-                $document->setAttribute('$tenant', $this->adapter->getTenant());
-            }
-        }
-
-        $document = $this->encode($collection, $document);
-
-        if ($this->validate) {
-            $validator = new Permissions();
-            if (!$validator->isValid($document->getPermissions())) {
-                throw new DatabaseException($validator->getDescription());
-            }
-        }
-
-        if ($this->validate) {
-            $structure = new Structure(
-                $collection,
-                $this->adapter->getIdAttributeType(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-                currentDocument: null
-            );
-            if (!$structure->isValid($document)) {
-                throw new StructureException($structure->getDescription());
-            }
-        }
-
-        $document = $this->adapter->castingBefore($collection, $document);
-
-        $document = $this->withTransaction(function () use ($collection, $document) {
-            if ($this->resolveRelationships) {
-                $document = $this->silent(fn () => $this->createDocumentRelationships($collection, $document));
-            }
-            return $this->adapter->createDocument($collection, $document);
-        });
-
-        // Clear any negative-cache entry for this id: a prior read may have
-        // recorded it as missing before this insert committed.
-        $this->withDocumentTenant($document, fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId()));
-
-        if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships) {
-            // Use the write stack depth for proper MAX_DEPTH enforcement during creation
-            $fetchDepth = count($this->relationshipWriteStack);
-            $documents = $this->silent(fn () => $this->populateDocumentsRelationships([$document], $collection, $fetchDepth));
-            $document = $this->adapter->castingAfter($collection, $documents[0]);
-        }
-
-        $document = $this->casting($collection, $document);
-        $document = $this->decode($collection, $document);
-
-        // Convert to custom document type if mapped
-        if (isset($this->documentTypes[$collection->getId()])) {
-            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
-        }
-
-        $this->trigger(self::EVENT_DOCUMENT_CREATE, $document);
-
-        return $document;
-    }
-
-    /**
-     * Create Documents in a batch
-     *
-     * @param string $collection
-     * @param array<Document> $documents
-     * @param int $batchSize
-     * @param (callable(Document): void)|null $onNext
-     * @param (callable(Throwable): void)|null $onError
-     * @return int
-     * @throws AuthorizationException
-     * @throws StructureException
-     * @throws \Throwable
-     * @throws Exception
-     */
-    public function createDocuments(
-        string $collection,
-        array $documents,
-        int $batchSize = self::INSERT_BATCH_SIZE,
-        ?callable $onNext = null,
-        ?callable $onError = null,
-    ): int {
-        if (!$this->adapter->getSharedTables() && $this->adapter->getTenantPerDocument()) {
-            throw new DatabaseException('Shared tables must be enabled if tenant per document is enabled.');
-        }
-
-        if (empty($documents)) {
-            return 0;
-        }
-
-        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        if ($collection->getId() !== self::METADATA) {
-            if (!$this->authorization->isValid(new Input(self::PERMISSION_CREATE, $collection->getCreate()))) {
-                throw new AuthorizationException($this->authorization->getDescription());
-            }
-        }
-
-        $time = DateTime::now();
-        $modified = 0;
-
-        foreach ($documents as $document) {
-            $createdAt = $document->getCreatedAt();
-            $updatedAt = $document->getUpdatedAt();
-
-            $document
-                ->setAttribute('$id', empty($document->getId()) ? ID::unique() : $document->getId())
-                ->setAttribute('$collection', $collection->getId())
-                ->setAttribute('$createdAt', ($createdAt === null || !$this->preserveDates) ? $time : $createdAt)
-                ->setAttribute('$updatedAt', ($updatedAt === null || !$this->preserveDates) ? $time : $updatedAt);
-
-            if (empty($document->getPermissions())) {
-                $document->setAttribute('$permissions', []);
-            }
-
-            if ($this->adapter->getSharedTables()) {
-                if ($this->adapter->getTenantPerDocument()) {
-                    if ($document->getTenant() === null) {
-                        throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
-                    }
-                } else {
-                    $document->setAttribute('$tenant', $this->adapter->getTenant());
-                }
-            }
-
-            $document = $this->encode($collection, $document);
-
-            if ($this->validate) {
-                $validator = new Structure(
-                    $collection,
-                    $this->adapter->getIdAttributeType(),
-                    $this->adapter->getMinDateTime(),
-                    $this->adapter->getMaxDateTime(),
-                    $this->adapter->getSupportForAttributes(),
-                    supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-                    currentDocument: null
-                );
-                if (!$validator->isValid($document)) {
-                    throw new StructureException($validator->getDescription());
-                }
-            }
-
-            if ($this->resolveRelationships) {
-                $document = $this->silent(fn () => $this->createDocumentRelationships($collection, $document));
-            }
-
-            $document = $this->adapter->castingBefore($collection, $document);
-        }
-
-        foreach (\array_chunk($documents, $batchSize) as $chunk) {
-            $insert = fn () => $this->withTransaction(fn () => $this->adapter->createDocuments($collection, $chunk));
-            // Set adapter flag before withTransaction so Mongo can opt out of a real txn.
-            $batch = $this->skipDuplicates
-                ? $this->adapter->skipDuplicates($insert)
-                : $insert();
-
-            $batch = $this->adapter->getSequences($collection->getId(), $batch);
-
-            if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships) {
-                $batch = $this->silent(fn () => $this->populateDocumentsRelationships($batch, $collection, $this->relationshipFetchDepth));
-            }
-
-            foreach ($batch as $document) {
-                $document = $this->adapter->castingAfter($collection, $document);
-                $document = $this->casting($collection, $document);
-                $document = $this->decode($collection, $document);
-
-                // Clear any negative-cache entry recorded before this insert.
-                $this->withDocumentTenant($document, fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId()));
-
-                try {
-                    $onNext && $onNext($document);
-                } catch (\Throwable $e) {
-                    $onError ? $onError($e) : throw $e;
-                }
-
-                $modified++;
-            }
-        }
-
-        $this->trigger(self::EVENT_DOCUMENTS_CREATE, new Document([
-            '$collection' => $collection->getId(),
-            'modified' => $modified
-        ]));
-
-        return $modified;
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     * @throws DatabaseException
-     */
-    private function createDocumentRelationships(Document $collection, Document $document): Document
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $relationships = \array_filter(
-            $attributes,
-            fn ($attribute) => $attribute['type'] === Database::VAR_RELATIONSHIP
-        );
-
-        $stackCount = count($this->relationshipWriteStack);
-
-        foreach ($relationships as $relationship) {
-            $key = $relationship['key'];
-            $value = $document->getAttribute($key);
-            $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-            $relationType = $relationship['options']['relationType'];
-            $twoWay = $relationship['options']['twoWay'];
-            $twoWayKey = $relationship['options']['twoWayKey'];
-            $side = $relationship['options']['side'];
-
-            if ($stackCount >= Database::RELATION_MAX_DEPTH - 1 && $this->relationshipWriteStack[$stackCount - 1] !== $relatedCollection->getId()) {
-                $document->removeAttribute($key);
-
-                continue;
-            }
-
-            $this->relationshipWriteStack[] = $collection->getId();
-
-            try {
-                switch (\gettype($value)) {
-                    case 'array':
-                        if (
-                            ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_CHILD) ||
-                            ($relationType === Database::RELATION_ONE_TO_ONE)
-                        ) {
-                            throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document, array given.');
-                        }
-
-                        // List of documents or IDs
-                        foreach ($value as $related) {
-                            switch (\gettype($related)) {
-                                case 'object':
-                                    if (!$related instanceof Document) {
-                                        throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-                                    }
-                                    $this->relateDocuments(
-                                        $collection,
-                                        $relatedCollection,
-                                        $key,
-                                        $document,
-                                        $related,
-                                        $relationType,
-                                        $twoWay,
-                                        $twoWayKey,
-                                        $side,
-                                    );
-                                    break;
-                                case 'string':
-                                    $this->relateDocumentsById(
-                                        $collection,
-                                        $relatedCollection,
-                                        $key,
-                                        $document->getId(),
-                                        $related,
-                                        $relationType,
-                                        $twoWay,
-                                        $twoWayKey,
-                                        $side,
-                                    );
-                                    break;
-                                default:
-                                    throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-                            }
-                        }
-                        $document->removeAttribute($key);
-                        break;
-
-                    case 'object':
-                        if (!$value instanceof Document) {
-                            throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-                        }
-
-                        if ($relationType === Database::RELATION_ONE_TO_ONE && !$twoWay && $side === Database::RELATION_SIDE_CHILD) {
-                            throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
-                        }
-
-                        if (
-                            ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD) ||
-                            ($relationType === Database::RELATION_MANY_TO_MANY)
-                        ) {
-                            throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, document given.');
-                        }
-
-                        $relatedId = $this->relateDocuments(
-                            $collection,
-                            $relatedCollection,
-                            $key,
-                            $document,
-                            $value,
-                            $relationType,
-                            $twoWay,
-                            $twoWayKey,
-                            $side,
-                        );
-                        $document->setAttribute($key, $relatedId);
-                        break;
-
-                    case 'string':
-                        if ($relationType === Database::RELATION_ONE_TO_ONE && $twoWay === false && $side === Database::RELATION_SIDE_CHILD) {
-                            throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
-                        }
-
-                        if (
-                            ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD) ||
-                            ($relationType === Database::RELATION_MANY_TO_MANY)
-                        ) {
-                            throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, document ID given.');
-                        }
-
-                        // Single document ID
-                        $this->relateDocumentsById(
-                            $collection,
-                            $relatedCollection,
-                            $key,
-                            $document->getId(),
-                            $value,
-                            $relationType,
-                            $twoWay,
-                            $twoWayKey,
-                            $side,
-                        );
-                        break;
-
-                    case 'NULL':
-                        // TODO: This might need to depend on the relation type, to be either set to null or removed?
-
-                        if (
-                            ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_CHILD) ||
-                            ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_ONE_TO_ONE && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_ONE_TO_ONE && $side === Database::RELATION_SIDE_CHILD && $twoWay === true)
-                        ) {
-                            break;
-                        }
-
-                        $document->removeAttribute($key);
-                        // No related document
-                        break;
-
-                    default:
-                        throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-                }
-            } finally {
-                \array_pop($this->relationshipWriteStack);
-            }
-        }
-
-        return $document;
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $relatedCollection
-     * @param string $key
-     * @param Document $document
-     * @param Document $relation
-     * @param string $relationType
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @param string $side
-     * @return string related document ID
-     *
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws StructureException
-     * @throws Exception
-     */
-    private function relateDocuments(
-        Document $collection,
-        Document $relatedCollection,
-        string $key,
-        Document $document,
-        Document $relation,
-        string $relationType,
-        bool $twoWay,
-        string $twoWayKey,
-        string $side,
-    ): string {
-        switch ($relationType) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($twoWay) {
-                    $relation->setAttribute($twoWayKey, $document->getId());
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $relation->setAttribute($twoWayKey, $document->getId());
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    $relation->setAttribute($twoWayKey, $document->getId());
-                }
-                break;
-        }
-
-        // Try to get the related document
-        $related = $this->getDocument($relatedCollection->getId(), $relation->getId());
-
-        if ($related->isEmpty()) {
-            // If the related document doesn't exist, create it, inheriting permissions if none are set
-            if (!isset($relation['$permissions'])) {
-                $relation->setAttribute('$permissions', $document->getPermissions());
-            }
-
-            $related = $this->createDocument($relatedCollection->getId(), $relation);
-        } elseif ($related->getAttributes() != $relation->getAttributes()) {
-            // If the related document exists and the data is not the same, update it
-            foreach ($relation->getAttributes() as $attribute => $value) {
-                $related->setAttribute($attribute, $value);
-            }
-
-            $related = $this->updateDocument($relatedCollection->getId(), $related->getId(), $related);
-        }
-
-        if ($relationType === Database::RELATION_MANY_TO_MANY) {
-            $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-            $this->createDocument($junction, new Document([
-                $key => $related->getId(),
-                $twoWayKey => $document->getId(),
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ]
-            ]));
-        }
-
-        return $related->getId();
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $relatedCollection
-     * @param string $key
-     * @param string $documentId
-     * @param string $relationId
-     * @param string $relationType
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @param string $side
-     * @return void
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws StructureException
-     * @throws Exception
-     */
-    private function relateDocumentsById(
-        Document $collection,
-        Document $relatedCollection,
-        string $key,
-        string $documentId,
-        string $relationId,
-        string $relationType,
-        bool $twoWay,
-        string $twoWayKey,
-        string $side,
-    ): void {
-        // Get the related document, will be empty on permissions failure
-        $related = $this->skipRelationships(fn () => $this->getDocument($relatedCollection->getId(), $relationId));
-
-        if ($related->isEmpty() && $this->checkRelationshipsExist) {
-            return;
-        }
-
-        switch ($relationType) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($twoWay) {
-                    $related->setAttribute($twoWayKey, $documentId);
-                    $this->skipRelationships(fn () => $this->updateDocument($relatedCollection->getId(), $relationId, $related));
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    $related->setAttribute($twoWayKey, $documentId);
-                    $this->skipRelationships(fn () => $this->updateDocument($relatedCollection->getId(), $relationId, $related));
-                }
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    $related->setAttribute($twoWayKey, $documentId);
-                    $this->skipRelationships(fn () => $this->updateDocument($relatedCollection->getId(), $relationId, $related));
-                }
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $this->purgeCachedDocument($relatedCollection->getId(), $relationId);
-
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                $this->skipRelationships(fn () => $this->createDocument($junction, new Document([
-                    $key => $relationId,
-                    $twoWayKey => $documentId,
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::update(Role::any()),
-                        Permission::delete(Role::any()),
-                    ]
-                ])));
-                break;
-        }
-    }
-
-    /**
-     * Update Document
-     *
-     * @param string $collection
-     * @param string $id
-     * @param Document $document
-     * @return Document
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws StructureException
-     */
-    public function updateDocument(string $collection, string $id, Document $document): Document
-    {
-        if (!$id) {
-            throw new DatabaseException('Must define $id attribute');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        $newUpdatedAt = $document->getUpdatedAt();
-        $hasOperators = false;
-        $document = $this->withTransaction(function () use ($collection, $id, $document, $newUpdatedAt, &$hasOperators) {
-            $time = DateTime::now();
-            $old = $this->authorization->skip(fn () => $this->silent(
-                fn () => $this->getDocument($collection->getId(), $id, forUpdate: true)
-            ));
-            if ($old->isEmpty()) {
-                return new Document();
-            }
-
-            $skipPermissionsUpdate = true;
-
-            if ($document->offsetExists('$permissions')) {
-                $originalPermissions = $old->getPermissions();
-                $currentPermissions = $document->getPermissions();
-
-                sort($originalPermissions);
-                sort($currentPermissions);
-
-                $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
-            }
-
-            // UID change
-            if ($document->offsetExists('$id') && $document->getId() !== $id) {
-                $skipPermissionsUpdate = false;
-            }
-
-            $createdAt = $document->getCreatedAt();
-
-            $document = \array_merge($old->getArrayCopy(), $document->getArrayCopy());
-            $document['$collection'] = $old->getAttribute('$collection'); // Make sure user doesn't switch collection ID
-            $document['$sequence'] = $old->getSequence(); // Sequence is immutable
-            $document['$createdAt'] = ($createdAt === null || !$this->preserveDates) ? $old->getCreatedAt() : $createdAt;
-
-            if ($this->adapter->getSharedTables()) {
-                $tenant = $old->getTenant();
-                $document['$tenant'] = $tenant;
-                $old->setAttribute('$tenant', $tenant); // Normalize for strict comparison
-            }
-            $document = new Document($document);
-
-            // Ahead of change detection: a dropped attribute is never persisted, so
-            // counting it as a change would bump $updatedAt and fire an update event
-            // for a write that leaves the stored document identical.
-            $document = $this->removeUnknownAttributes($collection, $document);
-
-            $attributes = $collection->getAttribute('attributes', []);
-
-            $relationships = \array_filter($attributes, function ($attribute) {
-                return $attribute['type'] === Database::VAR_RELATIONSHIP;
-            });
-
-            $shouldUpdate = false;
-
-            if ($collection->getId() !== self::METADATA) {
-                $documentSecurity = $collection->getAttribute('documentSecurity', false);
-
-                foreach ($relationships as $relationship) {
-                    $relationships[$relationship->getAttribute('key')] = $relationship;
-                }
-
-                foreach ($document as $key => $value) {
-                    if (Operator::isOperator($value)) {
-                        $shouldUpdate = true;
-                        break;
-                    }
-                }
-
-                // Compare if the document has any changes
-                foreach ($document as $key => $value) {
-                    if (\array_key_exists($key, $relationships)) {
-                        if (\count($this->relationshipWriteStack) >= Database::RELATION_MAX_DEPTH - 1) {
-                            continue;
-                        }
-
-                        $relationType = (string)$relationships[$key]['options']['relationType'];
-                        $side = (string)$relationships[$key]['options']['side'];
-                        switch ($relationType) {
-                            case Database::RELATION_ONE_TO_ONE:
-                                $oldValue = $old->getAttribute($key) instanceof Document
-                                    ? $old->getAttribute($key)->getId()
-                                    : $old->getAttribute($key);
-
-                                if ((\is_null($value) !== \is_null($oldValue))
-                                    || (\is_string($value) && $value !== $oldValue)
-                                    || ($value instanceof Document && $value->getId() !== $oldValue)
-                                ) {
-                                    $shouldUpdate = true;
-                                }
-                                break;
-                            case Database::RELATION_ONE_TO_MANY:
-                            case Database::RELATION_MANY_TO_ONE:
-                            case Database::RELATION_MANY_TO_MANY:
-                                if (
-                                    ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_PARENT) ||
-                                    ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_CHILD)
-                                ) {
-                                    $oldValue = $old->getAttribute($key) instanceof Document
-                                        ? $old->getAttribute($key)->getId()
-                                        : $old->getAttribute($key);
-
-                                    if ((\is_null($value) !== \is_null($oldValue))
-                                        || (\is_string($value) && $value !== $oldValue)
-                                        || ($value instanceof Document && $value->getId() !== $oldValue)
-                                    ) {
-                                        $shouldUpdate = true;
-                                    }
-                                    break;
-                                }
-
-                                if (Operator::isOperator($value)) {
-                                    $shouldUpdate = true;
-                                    break;
-                                }
-
-                                if (!\is_array($value) || !\array_is_list($value)) {
-                                    throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, ' . \gettype($value) . ' given.');
-                                }
-
-                                if (\count($old->getAttribute($key)) !== \count($value)) {
-                                    $shouldUpdate = true;
-                                    break;
-                                }
-
-                                foreach ($value as $index => $relation) {
-                                    $oldValue = $old->getAttribute($key)[$index] instanceof Document
-                                        ? $old->getAttribute($key)[$index]->getId()
-                                        : $old->getAttribute($key)[$index];
-
-                                    if (
-                                        (\is_string($relation) && $relation !== $oldValue) ||
-                                        ($relation instanceof Document && $relation->getId() !== $oldValue)
-                                    ) {
-                                        $shouldUpdate = true;
-                                        break;
-                                    }
-                                }
-                                break;
-                        }
-
-                        if ($shouldUpdate) {
-                            break;
-                        }
-
-                        continue;
-                    }
-
-                    $oldValue = $old->getAttribute($key);
-
-                    if (!self::valuesEqual($value, $oldValue)) {
-                        $shouldUpdate = true;
-                        break;
-                    }
-                }
-
-                $updatePermissions = [
-                    ...$collection->getUpdate(),
-                    ...($documentSecurity ? $old->getUpdate() : [])
-                ];
-
-                $readPermissions = [
-                    ...$collection->getRead(),
-                    ...($documentSecurity ? $old->getRead() : [])
-                ];
-
-                if ($shouldUpdate) {
-                    if (!$this->authorization->isValid(new Input(self::PERMISSION_UPDATE, $updatePermissions))) {
-                        throw new AuthorizationException($this->authorization->getDescription());
-                    }
-                } else {
-                    if (!$this->authorization->isValid(new Input(self::PERMISSION_READ, $readPermissions))) {
-                        throw new AuthorizationException($this->authorization->getDescription());
-                    }
-                }
-            }
-
-            if ($shouldUpdate) {
-                $document->setAttribute('$updatedAt', ($newUpdatedAt === null || !$this->preserveDates) ? $time : $newUpdatedAt);
-            }
-
-            // Check if document was updated after the request timestamp
-            $oldUpdatedAt = new \DateTime($old->getUpdatedAt());
-            if (!is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
-                throw new ConflictException('Document was updated after the request timestamp');
-            }
-
-            $document = $this->encode($collection, $document);
-
-            if ($this->validate) {
-                $structureValidator = new Structure(
-                    $collection,
-                    $this->adapter->getIdAttributeType(),
-                    $this->adapter->getMinDateTime(),
-                    $this->adapter->getMaxDateTime(),
-                    $this->adapter->getSupportForAttributes(),
-                    supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-                    currentDocument: $old
-                );
-                if (!$structureValidator->isValid($document)) { // Make sure updated structure still apply collection rules (if any)
-                    throw new StructureException($structureValidator->getDescription());
-                }
-            }
-
-            if ($this->resolveRelationships) {
-                $document = $this->silent(fn () => $this->updateDocumentRelationships($collection, $old, $document));
-            }
-
-            $document = $this->adapter->castingBefore($collection, $document);
-
-            $this->adapter->updateDocument($collection, $id, $document, $skipPermissionsUpdate);
-
-            $document = $this->adapter->castingAfter($collection, $document);
-
-            $this->purgeCachedDocument($collection->getId(), $id);
-
-            if ($document->getId() !== $id) {
-                $this->purgeCachedDocument($collection->getId(), $document->getId());
-            }
-
-            // If operators were used, refetch inside the transaction so the returned value reflects
-            // this operation's own write (read-your-writes). Refetching after commit could observe a
-            // concurrent update and return that value instead of the result of this operation.
-            foreach ($document->getArrayCopy() as $value) {
-                if (Operator::isOperator($value)) {
-                    $hasOperators = true;
-                    break;
-                }
-            }
-
-            if ($hasOperators) {
-                $refetched = $this->refetchDocuments($collection, [$document]);
-                $document = $refetched[0];
-            }
-
-            return $document;
-        });
-
-        if ($document->isEmpty()) {
-            return $document;
-        }
-
-        // Purge again after commit so readers cannot re-cache the pre-commit version
-        $this->purgeCachedDocumentInternal($collection->getId(), $id);
-
-        if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships) {
-            $documents = $this->silent(fn () => $this->populateDocumentsRelationships([$document], $collection, $this->relationshipFetchDepth));
-            $document = $documents[0];
-        }
-
-        // The operator refetch already returns a decoded document (via find()); decoding again
-        // would double-apply the decode filters.
-        if (!$hasOperators) {
-            $document = $this->decode($collection, $document);
-        }
-
-        // Convert to custom document type if mapped
-        if (isset($this->documentTypes[$collection->getId()])) {
-            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
-        }
-
-        $this->trigger(self::EVENT_DOCUMENT_UPDATE, $document);
-
-        return $document;
-    }
-
-    /**
-     * Update documents
-     *
-     * Updates all documents which match the given query.
-     *
-     * @param string $collection
-     * @param Document $updates
-     * @param array<Query> $queries
-     * @param int $batchSize
-     * @param (callable(Document $updated, Document $old): void)|null $onNext
-     * @param (callable(Throwable): void)|null $onError
-     * @return int
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DuplicateException
-     * @throws QueryException
-     * @throws StructureException
-     * @throws TimeoutException
-     * @throws \Throwable
-     * @throws Exception
-     */
-    public function updateDocuments(
-        string $collection,
-        Document $updates,
-        array $queries = [],
-        int $batchSize = self::INSERT_BATCH_SIZE,
-        ?callable $onNext = null,
-        ?callable $onError = null,
-    ): int {
-        if ($updates->isEmpty()) {
-            return 0;
-        }
-
-        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        if ($collection->isEmpty()) {
-            throw new DatabaseException('Collection not found');
-        }
-
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $this->authorization->isValid(new Input(self::PERMISSION_UPDATE, $collection->getUpdate()));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($this->authorization->getDescription());
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
-                $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMaxUIDLength(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForUnsignedBigInt()
-            );
-
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
-        }
-
-        $grouped = Query::groupByType($queries);
-        $limit = $grouped['limit'];
-        $cursor = $grouped['cursor'];
-
-        if (!empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
-            throw new DatabaseException("Cursor document must be from the same Collection.");
-        }
-
-        unset($updates['$id']);
-        unset($updates['$tenant']);
-
-        if (($updates->getCreatedAt() === null || !$this->preserveDates)) {
-            unset($updates['$createdAt']);
-        } else {
-            $updates['$createdAt'] = $updates->getCreatedAt();
-        }
-
-        if ($this->adapter->getSharedTables()) {
-            $updates['$tenant'] = $this->adapter->getTenant();
-        }
-
-        $updatedAt = $updates->getUpdatedAt();
-        $updates['$updatedAt'] = ($updatedAt === null || !$this->preserveDates) ? DateTime::now() : $updatedAt;
-
-        $updates = $this->encode(
-            $collection,
-            $updates,
-            applyDefaults: false
-        );
-
-        if ($this->validate) {
-            $validator = new PartialStructure(
-                $collection,
-                $this->adapter->getIdAttributeType(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-                currentDocument: null // No old document available in bulk updates
-            );
-
-            if (!$validator->isValid($updates)) {
-                throw new StructureException($validator->getDescription());
-            }
-        }
-
-        $originalLimit = $limit;
-        $last = $cursor;
-        $modified = 0;
-
-        while (true) {
-            if ($limit && $limit < $batchSize) {
-                $batchSize = $limit;
-            } elseif (!empty($limit)) {
-                $limit -= $batchSize;
-            }
-
-            $new = [
-                Query::limit($batchSize)
-            ];
-
-            if (!empty($last)) {
-                $new[] = Query::cursorAfter($last);
-            }
-
-            $batch = $this->silent(fn () => $this->find(
-                $collection->getId(),
-                array_merge($new, $queries),
-                forPermission: Database::PERMISSION_UPDATE
-            ));
-
-            if (empty($batch)) {
-                break;
-            }
-
-            $old = array_map(fn ($doc) => clone $doc, $batch);
-            $currentPermissions = $updates->getPermissions();
-            sort($currentPermissions);
-
-            $this->withTransaction(function () use ($collection, $updates, &$batch, $currentPermissions) {
-                foreach ($batch as $index => $document) {
-                    $skipPermissionsUpdate = true;
-
-                    if ($updates->offsetExists('$permissions')) {
-                        if (!$document->offsetExists('$permissions')) {
-                            throw new QueryException('Permission document missing in select');
-                        }
-
-                        $originalPermissions = $document->getPermissions();
-
-                        \sort($originalPermissions);
-
-                        $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
-                    }
-
-                    $document->setAttribute('$skipPermissionsUpdate', $skipPermissionsUpdate);
-
-                    $new = new Document(\array_merge($document->getArrayCopy(), $updates->getArrayCopy()));
-
-                    if ($this->resolveRelationships) {
-                        $this->silent(fn () => $this->updateDocumentRelationships($collection, $document, $new));
-                    }
-
-                    $document = $new;
-
-                    // Check if document was updated after the request timestamp
-                    try {
-                        $oldUpdatedAt = new \DateTime($document->getUpdatedAt());
-                    } catch (Exception $e) {
-                        throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
-                    }
-
-                    if (!is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
-                        throw new ConflictException('Document was updated after the request timestamp');
-                    }
-                    $encoded = $this->encode($collection, $document);
-                    $batch[$index] = $this->adapter->castingBefore($collection, $encoded);
-                }
-
-                $this->adapter->updateDocuments(
-                    $collection,
-                    $updates,
-                    $batch
-                );
-            });
-
-            $updates = $this->adapter->castingBefore($collection, $updates);
-
-            $hasOperators = false;
-            foreach ($updates->getArrayCopy() as $value) {
-                if (Operator::isOperator($value)) {
-                    $hasOperators = true;
-                    break;
-                }
-            }
-
-            if ($hasOperators) {
-                $batch = $this->refetchDocuments($collection, $batch, $grouped['selections']);
-            }
-
-            foreach ($batch as $index => $doc) {
-                $doc = $this->adapter->castingAfter($collection, $doc);
-                $doc->removeAttribute('$skipPermissionsUpdate');
-                $this->purgeCachedDocument($collection->getId(), $doc->getId());
-                // The operator refetch goes through find(), which already returns fully decoded
-                // documents. Decoding again would double-apply the decode filters (and, because
-                // this call passes no selections, re-materialize non-selected attributes).
-                if (!$hasOperators) {
-                    $doc = $this->decode($collection, $doc);
-                }
-                try {
-                    $onNext && $onNext($doc, $old[$index]);
-                } catch (Throwable $th) {
-                    $onError ? $onError($th) : throw $th;
-                }
-                $modified++;
-            }
-
-            if (count($batch) < $batchSize) {
-                break;
-            } elseif ($originalLimit && $modified == $originalLimit) {
-                break;
-            }
-
-            $last = \end($batch);
-        }
-
-        $this->trigger(self::EVENT_DOCUMENTS_UPDATE, new Document([
-            '$collection' => $collection->getId(),
-            'modified' => $modified
-        ]));
-
-        return $modified;
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $old
-     * @param Document $document
-     *
-     * @return Document
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws DuplicateException
-     * @throws StructureException
-     */
-    private function updateDocumentRelationships(Document $collection, Document $old, Document $document): Document
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $relationships = \array_filter($attributes, function ($attribute) {
-            return $attribute['type'] === Database::VAR_RELATIONSHIP;
-        });
-
-        $stackCount = count($this->relationshipWriteStack);
-
-        foreach ($relationships as $index => $relationship) {
-            /** @var string $key */
-            $key = $relationship['key'];
-            $value = $document->getAttribute($key);
-            $oldValue = $old->getAttribute($key);
-            $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-            $relationType = (string)$relationship['options']['relationType'];
-            $twoWay = (bool)$relationship['options']['twoWay'];
-            $twoWayKey = (string)$relationship['options']['twoWayKey'];
-            $side = (string)$relationship['options']['side'];
-
-            if (Operator::isOperator($value)) {
-                $operator = $value;
-                if ($operator->isArrayOperation()) {
-                    $existingIds = [];
-                    if (\is_array($oldValue)) {
-                        $existingIds = \array_map(function ($item) {
-                            if ($item instanceof Document) {
-                                return $item->getId();
-                            }
-                            return $item;
-                        }, $oldValue);
-                    }
-
-                    $value = $this->applyRelationshipOperator($operator, $existingIds);
-                    $document->setAttribute($key, $value);
-                }
-            }
-
-            if ($oldValue == $value) {
-                if (
-                    ($relationType === Database::RELATION_ONE_TO_ONE
-                        || ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_PARENT)) &&
-                    $value instanceof Document
-                ) {
-                    $document->setAttribute($key, $value->getId());
-                    continue;
-                }
-                $document->removeAttribute($key);
-                continue;
-            }
-
-            if ($stackCount >= Database::RELATION_MAX_DEPTH - 1 && $this->relationshipWriteStack[$stackCount - 1] !== $relatedCollection->getId()) {
-                $document->removeAttribute($key);
-                continue;
-            }
-
-            $this->relationshipWriteStack[] = $collection->getId();
-
-            try {
-                switch ($relationType) {
-                    case Database::RELATION_ONE_TO_ONE:
-                        if (!$twoWay) {
-                            if ($side === Database::RELATION_SIDE_CHILD) {
-                                throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
-                            }
-
-                            if (\is_string($value)) {
-                                $related = $this->skipRelationships(fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])]));
-                                if ($related->isEmpty()) {
-                                    // If no such document exists in related collection
-                                    // For one-one we need to update the related key to null if no relation exists
-                                    $document->setAttribute($key, null);
-                                }
-                            } elseif ($value instanceof Document) {
-                                $relationId = $this->relateDocuments(
-                                    $collection,
-                                    $relatedCollection,
-                                    $key,
-                                    $document,
-                                    $value,
-                                    $relationType,
-                                    false,
-                                    $twoWayKey,
-                                    $side,
-                                );
-                                $document->setAttribute($key, $relationId);
-                            } elseif (is_array($value)) {
-                                throw new RelationshipException('Invalid relationship value. Must be either a document, document ID or null. Array given.');
-                            }
-
-                            break;
-                        }
-
-                        switch (\gettype($value)) {
-                            case 'string':
-                                $related = $this->skipRelationships(
-                                    fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])])
-                                );
-
-                                if ($related->isEmpty()) {
-                                    // If no such document exists in related collection
-                                    // For one-one we need to update the related key to null if no relation exists
-                                    $document->setAttribute($key, null);
-                                    break;
-                                }
-                                if (
-                                    $oldValue?->getId() !== $value
-                                    && !($this->skipRelationships(fn () => $this->findOne($relatedCollection->getId(), [
-                                        Query::select(['$id']),
-                                        Query::equal($twoWayKey, [$value]),
-                                    ]))->isEmpty())
-                                ) {
-                                    // Have to do this here because otherwise relations would be updated before the database can throw the unique violation
-                                    throw new DuplicateException('Document already has a related document');
-                                }
-
-                                $this->skipRelationships(fn () => $this->updateDocument(
-                                    $relatedCollection->getId(),
-                                    $related->getId(),
-                                    $related->setAttribute($twoWayKey, $document->getId())
-                                ));
-                                break;
-                            case 'object':
-                                if ($value instanceof Document) {
-                                    $related = $this->skipRelationships(fn () => $this->getDocument($relatedCollection->getId(), $value->getId()));
-
-                                    if (
-                                        $oldValue?->getId() !== $value->getId()
-                                        && !($this->skipRelationships(fn () => $this->findOne($relatedCollection->getId(), [
-                                            Query::select(['$id']),
-                                            Query::equal($twoWayKey, [$value->getId()]),
-                                        ]))->isEmpty())
-                                    ) {
-                                        // Have to do this here because otherwise relations would be updated before the database can throw the unique violation
-                                        throw new DuplicateException('Document already has a related document');
-                                    }
-
-                                    $this->relationshipWriteStack[] = $relatedCollection->getId();
-                                    if ($related->isEmpty()) {
-                                        if (!isset($value['$permissions'])) {
-                                            $value->setAttribute('$permissions', $document->getAttribute('$permissions'));
-                                        }
-                                        $related = $this->createDocument(
-                                            $relatedCollection->getId(),
-                                            $value->setAttribute($twoWayKey, $document->getId())
-                                        );
-                                    } else {
-                                        $related = $this->updateDocument(
-                                            $relatedCollection->getId(),
-                                            $related->getId(),
-                                            $value->setAttribute($twoWayKey, $document->getId())
-                                        );
-                                    }
-                                    \array_pop($this->relationshipWriteStack);
-
-                                    $document->setAttribute($key, $related->getId());
-                                    break;
-                                }
-                                // no break
-                            case 'NULL':
-                                if (!\is_null($oldValue?->getId())) {
-                                    $oldRelated = $this->skipRelationships(
-                                        fn () => $this->getDocument($relatedCollection->getId(), $oldValue->getId())
-                                    );
-                                    $this->skipRelationships(fn () => $this->updateDocument(
-                                        $relatedCollection->getId(),
-                                        $oldRelated->getId(),
-                                        new Document([$twoWayKey => null])
-                                    ));
-                                }
-                                break;
-                            default:
-                                throw new RelationshipException('Invalid relationship value. Must be either a document, document ID or null.');
-                        }
-                        break;
-                    case Database::RELATION_ONE_TO_MANY:
-                    case Database::RELATION_MANY_TO_ONE:
-                        if (
-                            ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT) ||
-                            ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD)
-                        ) {
-                            if (!\is_array($value) || !\array_is_list($value)) {
-                                throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, ' . \gettype($value) . ' given.');
-                            }
-
-                            $oldIds = \array_map(fn ($document) => $document->getId(), $oldValue);
-
-                            $newIds = \array_map(function ($item) {
-                                if (\is_string($item)) {
-                                    return $item;
-                                } elseif ($item instanceof Document) {
-                                    return $item->getId();
-                                } else {
-                                    throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
-                                }
-                            }, $value);
-
-                            $removedDocuments = \array_diff($oldIds, $newIds);
-
-                            foreach ($removedDocuments as $relation) {
-                                $this->authorization->skip(fn () => $this->skipRelationships(fn () => $this->updateDocument(
-                                    $relatedCollection->getId(),
-                                    $relation,
-                                    new Document([$twoWayKey => null])
-                                )));
-                            }
-
-                            foreach ($value as $relation) {
-                                if (\is_string($relation)) {
-                                    $related = $this->skipRelationships(
-                                        fn () => $this->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])
-                                    );
-
-                                    if ($related->isEmpty()) {
-                                        continue;
-                                    }
-
-                                    $this->skipRelationships(fn () => $this->updateDocument(
-                                        $relatedCollection->getId(),
-                                        $related->getId(),
-                                        $related->setAttribute($twoWayKey, $document->getId())
-                                    ));
-                                } elseif ($relation instanceof Document) {
-                                    $related = $this->skipRelationships(
-                                        fn () => $this->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select(['$id'])])
-                                    );
-
-                                    if ($related->isEmpty()) {
-                                        if (!isset($relation['$permissions'])) {
-                                            $relation->setAttribute('$permissions', $document->getAttribute('$permissions'));
-                                        }
-                                        $this->createDocument(
-                                            $relatedCollection->getId(),
-                                            $relation->setAttribute($twoWayKey, $document->getId())
-                                        );
-                                    } else {
-                                        $this->updateDocument(
-                                            $relatedCollection->getId(),
-                                            $related->getId(),
-                                            $relation->setAttribute($twoWayKey, $document->getId())
-                                        );
-                                    }
-                                } else {
-                                    throw new RelationshipException('Invalid relationship value.');
-                                }
-                            }
-
-                            $document->removeAttribute($key);
-                            break;
-                        }
-
-                        if (\is_string($value)) {
-                            $related = $this->skipRelationships(
-                                fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])])
-                            );
-
-                            if ($related->isEmpty()) {
-                                // If no such document exists in related collection
-                                // For many-one we need to update the related key to null if no relation exists
-                                $document->setAttribute($key, null);
-                            }
-                            $this->purgeCachedDocument($relatedCollection->getId(), $value);
-                        } elseif ($value instanceof Document) {
-                            $related = $this->skipRelationships(
-                                fn () => $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$id'])])
-                            );
-
-                            if ($related->isEmpty()) {
-                                if (!isset($value['$permissions'])) {
-                                    $value->setAttribute('$permissions', $document->getAttribute('$permissions'));
-                                }
-                                $this->createDocument(
-                                    $relatedCollection->getId(),
-                                    $value
-                                );
-                            } elseif ($related->getAttributes() != $value->getAttributes()) {
-                                $this->updateDocument(
-                                    $relatedCollection->getId(),
-                                    $related->getId(),
-                                    $value
-                                );
-                                $this->purgeCachedDocument($relatedCollection->getId(), $related->getId());
-                            }
-
-                            $document->setAttribute($key, $value->getId());
-                        } elseif (\is_null($value)) {
-                            break;
-                        } elseif (is_array($value)) {
-                            throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document, array given.');
-                        } elseif (empty($value)) {
-                            throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document.');
-                        } else {
-                            throw new RelationshipException('Invalid relationship value.');
-                        }
-
-                        break;
-                    case Database::RELATION_MANY_TO_MANY:
-                        if (\is_null($value)) {
-                            break;
-                        }
-                        if (!\is_array($value)) {
-                            throw new RelationshipException('Invalid relationship value. Must be an array of documents or document IDs.');
-                        }
-
-                        $oldIds = \array_map(fn ($document) => $document->getId(), $oldValue);
-
-                        $newIds = \array_map(function ($item) {
-                            if (\is_string($item)) {
-                                return $item;
-                            } elseif ($item instanceof Document) {
-                                return $item->getId();
-                            } else {
-                                throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
-                            }
-                        }, $value);
-
-                        $removedDocuments = \array_diff($oldIds, $newIds);
-
-                        foreach ($removedDocuments as $relation) {
-                            $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                            $junctions = $this->find($junction, [
-                                Query::equal($key, [$relation]),
-                                Query::equal($twoWayKey, [$document->getId()]),
-                                Query::limit(PHP_INT_MAX)
-                            ]);
-
-                            foreach ($junctions as $junction) {
-                                $this->authorization->skip(fn () => $this->deleteDocument($junction->getCollection(), $junction->getId()));
-                            }
-                        }
-
-                        foreach ($value as $relation) {
-                            if (\is_string($relation)) {
-                                if (\in_array($relation, $oldIds) || $this->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])->isEmpty()) {
-                                    continue;
-                                }
-                            } elseif ($relation instanceof Document) {
-                                $related = $this->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select(['$id'])]);
-
-                                if ($related->isEmpty()) {
-                                    if (!isset($value['$permissions'])) {
-                                        $relation->setAttribute('$permissions', $document->getAttribute('$permissions'));
-                                    }
-                                    $related = $this->createDocument(
-                                        $relatedCollection->getId(),
-                                        $relation
-                                    );
-                                } elseif ($related->getAttributes() != $relation->getAttributes()) {
-                                    $related = $this->updateDocument(
-                                        $relatedCollection->getId(),
-                                        $related->getId(),
-                                        $relation
-                                    );
-                                }
-
-                                if (\in_array($relation->getId(), $oldIds)) {
-                                    continue;
-                                }
-
-                                $relation = $related->getId();
-                            } else {
-                                throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
-                            }
-
-                            $this->skipRelationships(fn () => $this->createDocument(
-                                $this->getJunctionCollection($collection, $relatedCollection, $side),
-                                new Document([
-                                    $key => $relation,
-                                    $twoWayKey => $document->getId(),
-                                    '$permissions' => [
-                                        Permission::read(Role::any()),
-                                        Permission::update(Role::any()),
-                                        Permission::delete(Role::any()),
-                                    ],
-                                ])
-                            ));
-                        }
-
-                        $document->removeAttribute($key);
-                        break;
-                }
-            } finally {
-                \array_pop($this->relationshipWriteStack);
-            }
-        }
-
-        return $document;
-    }
-
-    private function getJunctionCollection(Document $collection, Document $relatedCollection, string $side): string
-    {
-        return $side === Database::RELATION_SIDE_PARENT
-            ? '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence()
-            : '_' . $relatedCollection->getSequence() . '_' . $collection->getSequence();
-    }
-
-    /**
-     * Apply an operator to a relationship array of IDs
-     *
-     * @param Operator $operator
-     * @param array<string> $existingIds
-     * @return array<string|Document>
-     */
-    private function applyRelationshipOperator(Operator $operator, array $existingIds): array
-    {
-        $method = $operator->getMethod();
-        $values = $operator->getValues();
-
-        // Extract IDs from operator values (could be strings or Documents)
-        $valueIds = \array_filter(\array_map(fn ($item) => $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null), $values));
-
-        switch ($method) {
-            case Operator::TYPE_ARRAY_APPEND:
-                return \array_values(\array_merge($existingIds, $valueIds));
-
-            case Operator::TYPE_ARRAY_PREPEND:
-                return \array_values(\array_merge($valueIds, $existingIds));
-
-            case Operator::TYPE_ARRAY_INSERT:
-                $index = $values[0] ?? 0;
-                $item = $values[1] ?? null;
-                $itemId = $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null);
-                if ($itemId !== null) {
-                    \array_splice($existingIds, $index, 0, [$itemId]);
-                }
-                return \array_values($existingIds);
-
-            case Operator::TYPE_ARRAY_REMOVE:
-                $toRemove = $values[0] ?? null;
-                if (\is_array($toRemove)) {
-                    $toRemoveIds = \array_filter(\array_map(fn ($item) => $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null), $toRemove));
-                    return \array_values(\array_diff($existingIds, $toRemoveIds));
-                }
-                $toRemoveId = $toRemove instanceof Document ? $toRemove->getId() : (\is_string($toRemove) ? $toRemove : null);
-                if ($toRemoveId !== null) {
-                    return \array_values(\array_diff($existingIds, [$toRemoveId]));
-                }
-                return $existingIds;
-
-            case Operator::TYPE_ARRAY_UNIQUE:
-                return \array_values(\array_unique($existingIds));
-
-            case Operator::TYPE_ARRAY_INTERSECT:
-                return \array_values(\array_intersect($existingIds, $valueIds));
-
-            case Operator::TYPE_ARRAY_DIFF:
-                return \array_values(\array_diff($existingIds, $valueIds));
-
-            default:
-                return $existingIds;
-        }
-    }
-
-    /**
-     * Create or update a document.
-     *
-     * @param string $collection
-     * @param Document $document
-     * @return Document
-     * @throws StructureException
-     * @throws Throwable
-     */
-    public function upsertDocument(
-        string $collection,
-        Document $document,
-    ): Document {
-        $result = null;
-
-        $this->upsertDocumentsWithIncrease(
-            $collection,
-            '',
-            [$document],
-            function (Document $doc, ?Document $_old = null) use (&$result) {
-                $result = $doc;
-            }
-        );
-
-        if ($result === null) {
-            // No-op (unchanged): return the current persisted doc
-            $result = $this->getDocument($collection, $document->getId());
-        }
-        return $result;
-    }
-
-    /**
-     * Create or update documents.
-     *
-     * @param string $collection
-     * @param array<Document> $documents
-     * @param int $batchSize
-     * @param (callable(Document, ?Document): void)|null $onNext
-     * @param (callable(Throwable): void)|null $onError
-     * @return int
-     * @throws StructureException
-     * @throws \Throwable
-     */
-    public function upsertDocuments(
-        string $collection,
-        array $documents,
-        int $batchSize = self::INSERT_BATCH_SIZE,
-        ?callable $onNext = null,
-        ?callable $onError = null
-    ): int {
-        return $this->upsertDocumentsWithIncrease(
-            $collection,
-            '',
-            $documents,
-            $onNext,
-            $onError,
-            $batchSize
-        );
-    }
-
-    /**
-     * Create or update documents, increasing the value of the given attribute by the value in each document.
-     *
-     * @param string $collection
-     * @param string $attribute
-     * @param array<Document> $documents
-     * @param (callable(Document, ?Document): void)|null $onNext
-     * @param (callable(Throwable): void)|null $onError
-     * @param int $batchSize
-     * @return int
-     * @throws StructureException
-     * @throws \Throwable
-     * @throws Exception
-     */
-    public function upsertDocumentsWithIncrease(
-        string $collection,
-        string $attribute,
-        array $documents,
-        ?callable $onNext = null,
-        ?callable $onError = null,
-        int $batchSize = self::INSERT_BATCH_SIZE
-    ): int {
-        if (empty($documents)) {
-            return 0;
-        }
-
-        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $collectionAttributes = $collection->getAttribute('attributes', []);
-        $time = DateTime::now();
-        $created = 0;
-        $updated = 0;
-        $seenIds = [];
-
-        // Batch-fetch existing documents in one query instead of N individual getDocument() calls.
-        // tenantPerDocument: group ids by tenant and run one find() per tenant under withTenant,
-        // so cross-tenant batches (e.g. StatsUsage worker) don't get silently scoped to the
-        // session tenant and miss rows belonging to other tenants.
-        $existingDocs = [];
-
-        if ($this->getSharedTables() && $this->getTenantPerDocument()) {
-            $idsByTenant = [];
-            foreach ($documents as $doc) {
-                if ($doc->getId() !== '') {
-                    $idsByTenant[$doc->getTenant()][] = $doc->getId();
-                }
-            }
-            foreach ($idsByTenant as $tenant => $tenantIds) {
-                $tenantIds = \array_values(\array_unique($tenantIds));
-                foreach (\array_chunk($tenantIds, \max(1, $this->maxQueryValues)) as $chunk) {
-                    $found = $this->authorization->skip(fn () => $this->withTenant($tenant, fn () => $this->silent(
-                        fn () => $this->find($collection->getId(), [
-                            Query::equal('$id', $chunk),
-                            Query::limit($this->maxQueryValues),
-                        ])
-                    )));
-                    foreach ($found as $doc) {
-                        $existingDocs[$this->tenantKey($doc)] = $doc;
-                    }
-                }
-            }
-        } else {
-            $docIds = \array_values(\array_unique(\array_filter(
-                \array_map(fn (Document $doc) => $doc->getId(), $documents),
-                fn ($id) => $id !== ''
-            )));
-
-            if (!empty($docIds)) {
-                foreach (\array_chunk($docIds, \max(1, $this->maxQueryValues)) as $chunk) {
-                    $existing = $this->authorization->skip(fn () => $this->silent(
-                        fn () => $this->find($collection->getId(), [
-                            Query::equal('$id', $chunk),
-                            Query::limit($this->maxQueryValues),
-                        ])
-                    ));
-                    foreach ($existing as $doc) {
-                        $existingDocs[$this->tenantKey($doc)] = $doc;
-                    }
-                }
-            }
-        }
-
-        foreach ($documents as $key => $document) {
-            $old = $existingDocs[$this->tenantKey($document)] ?? new Document();
-
-            $document = $this->removeUnknownAttributes($collection, $document);
-
-            // Extract operators early to avoid comparison issues
-            $documentArray = $document->getArrayCopy();
-            $extracted = Operator::extractOperators($documentArray);
-            $operators = $extracted['operators'];
-            $regularUpdates = $extracted['updates'];
-
-            $internalKeys = \array_map(
-                fn ($attr) => $attr['$id'],
-                self::INTERNAL_ATTRIBUTES
-            );
-
-            $regularUpdatesUserOnly = \array_diff_key($regularUpdates, \array_flip($internalKeys));
-
-            $skipPermissionsUpdate = true;
-
-            if ($document->offsetExists('$permissions')) {
-                $originalPermissions = $old->getPermissions();
-                $currentPermissions = $document->getPermissions();
-
-                sort($originalPermissions);
-                sort($currentPermissions);
-
-                $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
-            }
-
-            // Only skip if no operators and regular attributes haven't changed
-            $hasChanges = false;
-            if (!empty($operators)) {
-                $hasChanges = true;
-            } elseif (!empty($attribute)) {
-                $hasChanges = true;
-            } elseif (!$skipPermissionsUpdate) {
-                $hasChanges = true;
-            } else {
-                // Check if any of the provided attributes differ from old document
-                $oldAttributes = $old->getAttributes();
-                foreach ($regularUpdatesUserOnly as $attrKey => $value) {
-                    $oldValue = $oldAttributes[$attrKey] ?? null;
-                    if ($oldValue != $value) {
-                        $hasChanges = true;
-                        break;
-                    }
-                }
-
-                // Also check if old document has attributes that new document doesn't
-                if (!$hasChanges) {
-                    $internalKeys = \array_map(
-                        fn ($attr) => $attr['$id'],
-                        self::INTERNAL_ATTRIBUTES
-                    );
-
-                    $oldUserAttributes = array_diff_key($oldAttributes, array_flip($internalKeys));
-
-                    foreach (array_keys($oldUserAttributes) as $oldAttrKey) {
-                        if (!array_key_exists($oldAttrKey, $regularUpdatesUserOnly)) {
-                            // Old document has an attribute that new document doesn't
-                            $hasChanges = true;
-                            break;
-                        }
-                    }
-                }
-            }
-
-            if (!$hasChanges) {
-                // If not updating a single attribute and the document is the same as the old one, skip it
-                unset($documents[$key]);
-                continue;
-            }
-
-            // If old is empty, check if user has create permission on the collection
-            // If old is not empty, check if user has update permission on the collection
-            // If old is not empty AND documentSecurity is enabled, check if user has update permission on the collection or document
-
-
-            if ($old->isEmpty()) {
-                if (!$this->authorization->isValid(new Input(self::PERMISSION_CREATE, $collection->getCreate()))) {
-                    throw new AuthorizationException($this->authorization->getDescription());
-                }
-            } elseif (!$this->authorization->isValid(new Input(self::PERMISSION_UPDATE, [
-                ...$collection->getUpdate(),
-                ...($documentSecurity ? $old->getUpdate() : [])
-            ]))) {
-                throw new AuthorizationException($this->authorization->getDescription());
-            }
-
-            $updatedAt = $document->getUpdatedAt();
-
-            $document
-                ->setAttribute('$id', empty($document->getId()) ? ID::unique() : $document->getId())
-                ->setAttribute('$collection', $collection->getId())
-                ->setAttribute('$updatedAt', ($updatedAt === null || !$this->preserveDates) ? $time : $updatedAt);
-
-            if (!$this->preserveSequence) {
-                $document->removeAttribute('$sequence');
-            }
-
-            $createdAt = $document->getCreatedAt();
-            if ($createdAt === null || !$this->preserveDates) {
-                $document->setAttribute('$createdAt', $old->isEmpty() ? $time : $old->getCreatedAt());
-            } else {
-                $document->setAttribute('$createdAt', $createdAt);
-            }
-
-            // Force matching optional parameter sets
-            // Doesn't use decode as that intentionally skips null defaults to reduce payload size
-            foreach ($collectionAttributes as $attr) {
-                if (!$attr->getAttribute('required') && !\array_key_exists($attr['$id'], (array)$document)) {
-                    $document->setAttribute(
-                        $attr['$id'],
-                        $old->getAttribute($attr['$id'], ($attr['default'] ?? null))
-                    );
-                }
-            }
-
-            if ($skipPermissionsUpdate) {
-                $document->setAttribute('$permissions', $old->getPermissions());
-            }
-
-            if ($this->adapter->getSharedTables()) {
-                if ($this->adapter->getTenantPerDocument()) {
-                    if ($document->getTenant() === null) {
-                        throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
-                    }
-                    if (!$old->isEmpty() && $old->getTenant() != $document->getTenant()) {
-                        throw new DatabaseException('Tenant cannot be changed.');
-                    }
-                } else {
-                    $document->setAttribute('$tenant', $this->adapter->getTenant());
-                }
-            }
-
-            $document = $this->encode($collection, $document);
-
-            if ($this->validate) {
-                $validator = new Structure(
-                    $collection,
-                    $this->adapter->getIdAttributeType(),
-                    $this->adapter->getMinDateTime(),
-                    $this->adapter->getMaxDateTime(),
-                    $this->adapter->getSupportForAttributes(),
-                    supportUnsignedBigInt: $this->adapter->getSupportForUnsignedBigInt(),
-                    currentDocument: $old->isEmpty() ? null : $old
-                );
-
-                if (!$validator->isValid($document)) {
-                    throw new StructureException($validator->getDescription());
-                }
-            }
-
-            if (!$old->isEmpty()) {
-                // Check if document was updated after the request timestamp
-                try {
-                    $oldUpdatedAt = new \DateTime($old->getUpdatedAt());
-                } catch (Exception $e) {
-                    throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
-                }
-
-                if (!\is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
-                    throw new ConflictException('Document was updated after the request timestamp');
-                }
-            }
-
-            if ($this->resolveRelationships) {
-                $document = $this->silent(fn () => $this->createDocumentRelationships($collection, $document));
-            }
-
-            $seenIds[] = $this->tenantKey($document);
-            $old = $this->adapter->castingBefore($collection, $old);
-            $document = $this->adapter->castingBefore($collection, $document);
-
-            $documents[$key] = new Change(
-                old: $old,
-                new: $document
-            );
-        }
-
-        // Required because *some* DBs will allow duplicate IDs for upsert
-        if (\count($seenIds) !== \count(\array_unique($seenIds))) {
-            throw new DuplicateException('Duplicate document IDs found in the input array.');
-        }
-
-        foreach (\array_chunk($documents, $batchSize) as $chunk) {
-            /**
-             * @var array<Change> $chunk
-             */
-            $batch = $this->withTransaction(fn () => $this->authorization->skip(fn () => $this->adapter->upsertDocuments(
-                $collection,
-                $attribute,
-                $chunk
-            )));
-
-            $batch = $this->adapter->getSequences($collection->getId(), $batch);
-
-            foreach ($chunk as $change) {
-                if ($change->getOld()->isEmpty()) {
-                    $created++;
-                } else {
-                    $updated++;
-                }
-            }
-
-            if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships) {
-                $batch = $this->silent(fn () => $this->populateDocumentsRelationships($batch, $collection, $this->relationshipFetchDepth));
-            }
-
-            // Check if any document in the batch contains operators
-            $hasOperators = false;
-            foreach ($batch as $doc) {
-                $extracted = Operator::extractOperators($doc->getArrayCopy());
-                if (!empty($extracted['operators'])) {
-                    $hasOperators = true;
-                    break;
-                }
-            }
-
-            if ($hasOperators) {
-                $batch = $this->refetchDocuments($collection, $batch);
-            }
-
-            foreach ($batch as $index => $doc) {
-                $doc = $this->adapter->castingAfter($collection, $doc);
-                if (!$hasOperators) {
-                    $doc = $this->decode($collection, $doc);
-                }
-
-                $this->withDocumentTenant($doc, fn () => $this->purgeCachedDocument($collection->getId(), $doc->getId()));
-
-                $old = $chunk[$index]->getOld();
-
-                if (!$old->isEmpty()) {
-                    $old = $this->adapter->castingAfter($collection, $old);
-                }
-
-                try {
-                    $onNext && $onNext($doc, $old->isEmpty() ? null : $old);
-                } catch (\Throwable $th) {
-                    $onError ? $onError($th) : throw $th;
-                }
-            }
-        }
-
-        $this->trigger(self::EVENT_DOCUMENTS_UPSERT, new Document([
-            '$collection' => $collection->getId(),
-            'created' => $created,
-            'updated' => $updated,
-        ]));
-
-        return $created + $updated;
-    }
-
-    /**
-     * Increase a document attribute by a value
-     *
-     * @param string $collection The collection ID
-     * @param string $id The document ID
-     * @param string $attribute The attribute to increase
-     * @param int|float $value The value to increase the attribute by, can be a float
-     * @param int|float|null $max The maximum value the attribute can reach after the increase, null means no limit
-     * @return Document
-     * @throws AuthorizationException
-     * @throws DatabaseException
-     * @throws LimitException
-     * @throws NotFoundException
-     * @throws TypeException
-     * @throws \Throwable
-     */
-    public function increaseDocumentAttribute(
-        string $collection,
-        string $id,
-        string $attribute,
-        int|float $value = 1,
-        int|float|null $max = null
-    ): Document {
-        if ($value <= 0) { // Can be a float
-            throw new \InvalidArgumentException('Value must be numeric and greater than 0');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        if ($this->adapter->getSupportForAttributes()) {
-            $attr = \array_filter($collection->getAttribute('attributes', []), function ($a) use ($attribute) {
-                return $a['$id'] === $attribute;
-            });
-
-            if (empty($attr)) {
-                throw new NotFoundException('Attribute not found');
-            }
-
-            $whiteList = [
-                self::VAR_INTEGER,
-                self::VAR_BIGINT,
-                self::VAR_FLOAT
-            ];
-
-            /** @var Document $attr */
-            $attr = \end($attr);
-            if (!\in_array($attr->getAttribute('type'), $whiteList) || $attr->getAttribute('array')) {
-                throw new TypeException('Attribute must be an integer or float and can not be an array.');
-            }
-        }
-
-        $document = $this->withTransaction(function () use ($collection, $id, $attribute, $value, $max) {
-            /* @var $document Document */
-            $document = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument($collection->getId(), $id, forUpdate: true))); // Skip ensures user does not need read permission for this
-
-            if ($document->isEmpty()) {
-                throw new NotFoundException('Document not found');
-            }
-
-            if ($collection->getId() !== self::METADATA) {
-                $documentSecurity = $collection->getAttribute('documentSecurity', false);
-
-                if (!$this->authorization->isValid(new Input(self::PERMISSION_UPDATE, [
-                    ...$collection->getUpdate(),
-                    ...($documentSecurity ? $document->getUpdate() : [])
-                ]))) {
-                    throw new AuthorizationException($this->authorization->getDescription());
-                }
-            }
-
-            if (!\is_null($max) && ($document->getAttribute($attribute) + $value > $max)) {
-                throw new LimitException('Attribute value exceeds maximum limit: ' . $max);
-            }
-
-            $time = DateTime::now();
-            $updatedAt = $document->getUpdatedAt();
-            $updatedAt = (empty($updatedAt) || !$this->preserveDates) ? $time : DateTime::format(new \DateTime($updatedAt));
-            $max = $max ? $max - $value : null;
-
-            $this->adapter->increaseDocumentAttribute(
-                $collection->getId(),
-                $id,
-                $attribute,
-                $value,
-                $updatedAt,
-                max: $max
-            );
-
-            return $document->setAttribute(
-                $attribute,
-                $document->getAttribute($attribute) + $value
-            );
-        });
-
-        $this->purgeCachedDocument($collection->getId(), $id);
-
-        $this->trigger(self::EVENT_DOCUMENT_INCREASE, $document);
-
-        return $document;
-    }
-
-
-    /**
-     * Decrease a document attribute by a value
-     *
-     * @param string $collection
-     * @param string $id
-     * @param string $attribute
-     * @param int|float $value
-     * @param int|float|null $min
-     * @return Document
-     *
-     * @throws AuthorizationException
-     * @throws DatabaseException
-     */
-    public function decreaseDocumentAttribute(
-        string $collection,
-        string $id,
-        string $attribute,
-        int|float $value = 1,
-        int|float|null $min = null
-    ): Document {
-        if ($value <= 0) { // Can be a float
-            throw new \InvalidArgumentException('Value must be numeric and greater than 0');
-        }
-
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($this->adapter->getSupportForAttributes()) {
-            $attr = \array_filter($collection->getAttribute('attributes', []), function ($a) use ($attribute) {
-                return $a['$id'] === $attribute;
-            });
-
-            if (empty($attr)) {
-                throw new NotFoundException('Attribute not found');
-            }
-
-            $whiteList = [
-                self::VAR_INTEGER,
-                self::VAR_BIGINT,
-                self::VAR_FLOAT
-            ];
-
-            /**
-             * @var Document $attr
-             */
-            $attr = \end($attr);
-            if (!\in_array($attr->getAttribute('type'), $whiteList) || $attr->getAttribute('array')) {
-                throw new TypeException('Attribute must be an integer or float and can not be an array.');
-            }
-        }
-
-        $document = $this->withTransaction(function () use ($collection, $id, $attribute, $value, $min) {
-            /* @var $document Document */
-            $document = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument($collection->getId(), $id, forUpdate: true))); // Skip ensures user does not need read permission for this
-
-            if ($document->isEmpty()) {
-                throw new NotFoundException('Document not found');
-            }
-
-            if ($collection->getId() !== self::METADATA) {
-                $documentSecurity = $collection->getAttribute('documentSecurity', false);
-
-                if (!$this->authorization->isValid(new Input(self::PERMISSION_UPDATE, [
-                    ...$collection->getUpdate(),
-                    ...($documentSecurity ? $document->getUpdate() : [])
-                ]))) {
-                    throw new AuthorizationException($this->authorization->getDescription());
-                }
-            }
-
-            if (!\is_null($min) && ($document->getAttribute($attribute) - $value < $min)) {
-                throw new LimitException('Attribute value exceeds minimum limit: ' . $min);
-            }
-
-            $time = DateTime::now();
-            $updatedAt = $document->getUpdatedAt();
-            $updatedAt = (empty($updatedAt) || !$this->preserveDates) ? $time : DateTime::format(new \DateTime($updatedAt));
-            $min = $min ? $min + $value : null;
-
-            $this->adapter->increaseDocumentAttribute(
-                $collection->getId(),
-                $id,
-                $attribute,
-                $value * -1,
-                $updatedAt,
-                min: $min
-            );
-
-            return $document->setAttribute(
-                $attribute,
-                $document->getAttribute($attribute) - $value
-            );
-        });
-
-        $this->purgeCachedDocument($collection->getId(), $id);
-
-        $this->trigger(self::EVENT_DOCUMENT_DECREASE, $document);
-
-        return $document;
-    }
-
-    /**
-     * Delete Document
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     *
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     */
-    public function deleteDocument(string $collection, string $id): bool
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        $deleted = $this->withTransaction(function () use ($collection, $id, &$document) {
-            $document = $this->authorization->skip(fn () => $this->silent(
-                fn () => $this->getDocument($collection->getId(), $id, forUpdate: true)
-            ));
-
-            if ($document->isEmpty()) {
-                return false;
-            }
-
-            if ($collection->getId() !== self::METADATA) {
-                $documentSecurity = $collection->getAttribute('documentSecurity', false);
-
-                if (!$this->authorization->isValid(new Input(self::PERMISSION_DELETE, [
-                    ...$collection->getDelete(),
-                    ...($documentSecurity ? $document->getDelete() : [])
-                ]))) {
-                    throw new AuthorizationException($this->authorization->getDescription());
-                }
-            }
-
-            // Check if document was updated after the request timestamp
-            try {
-                $oldUpdatedAt = new \DateTime($document->getUpdatedAt());
-            } catch (Exception $e) {
-                throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
-            }
-
-            if (!\is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
-                throw new ConflictException('Document was updated after the request timestamp');
-            }
-
-            if ($this->resolveRelationships) {
-                $document = $this->silent(fn () => $this->deleteDocumentRelationships($collection, $document));
-            }
-
-            $result = $this->adapter->deleteDocument($collection->getId(), $id);
-
-            $this->purgeCachedDocument($collection->getId(), $id);
-
-            return $result;
-        });
-
-        if ($deleted) {
-            // Purge again after commit so readers cannot re-cache the pre-commit version
-            $this->purgeCachedDocumentInternal($collection->getId(), $id);
-            $this->trigger(self::EVENT_DOCUMENT_DELETE, $document);
-        }
-
-        return $deleted;
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     * @throws StructureException
-     */
-    private function deleteDocumentRelationships(Document $collection, Document $document): Document
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-
-        $relationships = \array_filter($attributes, function ($attribute) {
-            return $attribute['type'] === Database::VAR_RELATIONSHIP;
-        });
-
-        foreach ($relationships as $relationship) {
-            $key = $relationship['key'];
-            $value = $document->getAttribute($key);
-            $relatedCollection = $this->getCollection($relationship['options']['relatedCollection']);
-            $relationType = $relationship['options']['relationType'];
-            $twoWay = $relationship['options']['twoWay'];
-            $twoWayKey = $relationship['options']['twoWayKey'];
-            $onDelete = $relationship['options']['onDelete'];
-            $side = $relationship['options']['side'];
-
-            $relationship->setAttribute('collection', $collection->getId());
-            $relationship->setAttribute('document', $document->getId());
-
-            switch ($onDelete) {
-                case Database::RELATION_MUTATE_RESTRICT:
-                    $this->deleteRestrict($relatedCollection, $document, $value, $relationType, $twoWay, $twoWayKey, $side);
-                    break;
-                case Database::RELATION_MUTATE_SET_NULL:
-                    $this->deleteSetNull($collection, $relatedCollection, $document, $value, $relationType, $twoWay, $twoWayKey, $side);
-                    break;
-                case Database::RELATION_MUTATE_CASCADE:
-                    foreach ($this->relationshipDeleteStack as $processedRelationship) {
-                        $existingKey = $processedRelationship['key'];
-                        $existingCollection = $processedRelationship['collection'];
-                        $existingRelatedCollection = $processedRelationship['options']['relatedCollection'];
-                        $existingTwoWayKey = $processedRelationship['options']['twoWayKey'];
-                        $existingSide = $processedRelationship['options']['side'];
-
-                        // If this relationship has already been fetched for this document, skip it
-                        $reflexive = $processedRelationship == $relationship;
-
-                        // If this relationship is the same as a previously fetched relationship, but on the other side, skip it
-                        $symmetric = $existingKey === $twoWayKey
-                            && $existingTwoWayKey === $key
-                            && $existingRelatedCollection === $collection->getId()
-                            && $existingCollection === $relatedCollection->getId()
-                            && $existingSide !== $side;
-
-                        // If this relationship is not directly related but relates across multiple collections, skip it.
-                        //
-                        // These conditions ensure that a relationship is considered transitive if it has the same
-                        // two-way key and related collection, but is on the opposite side of the relationship (the first and second conditions).
-                        //
-                        // They also ensure that a relationship is considered transitive if it has the same key and related
-                        // collection as an existing relationship, but a different two-way key (the third condition),
-                        // or the same two-way key as an existing relationship, but a different key (the fourth condition).
-                        $transitive = (($existingKey === $twoWayKey
-                                && $existingCollection === $relatedCollection->getId()
-                                && $existingSide !== $side)
-                            || ($existingTwoWayKey === $key
-                                && $existingRelatedCollection === $collection->getId()
-                                && $existingSide !== $side)
-                            || ($existingKey === $key
-                                && $existingTwoWayKey !== $twoWayKey
-                                && $existingRelatedCollection === $relatedCollection->getId()
-                                && $existingSide !== $side)
-                            || ($existingKey !== $key
-                                && $existingTwoWayKey === $twoWayKey
-                                && $existingRelatedCollection === $relatedCollection->getId()
-                                && $existingSide !== $side));
-
-                        if ($reflexive || $symmetric || $transitive) {
-                            break 2;
-                        }
-                    }
-                    $this->deleteCascade($collection, $relatedCollection, $document, $key, $value, $relationType, $twoWayKey, $side, $relationship);
-                    break;
-            }
-        }
-
-        return $document;
-    }
-
-    /**
-     * @param Document $relatedCollection
-     * @param Document $document
-     * @param mixed $value
-     * @param string $relationType
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @param string $side
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     * @throws StructureException
-     */
-    private function deleteRestrict(
-        Document $relatedCollection,
-        Document $document,
-        mixed $value,
-        string $relationType,
-        bool $twoWay,
-        string $twoWayKey,
-        string $side
-    ): void {
-        if ($value instanceof Document && $value->isEmpty()) {
-            $value = null;
-        }
-
-        if (
-            !empty($value)
-            && $relationType !== Database::RELATION_MANY_TO_ONE
-            && $side === Database::RELATION_SIDE_PARENT
-        ) {
-            throw new RestrictedException('Cannot delete document because it has at least one related document.');
-        }
-
-        if (
-            $relationType === Database::RELATION_ONE_TO_ONE
-            && $side === Database::RELATION_SIDE_CHILD
-            && !$twoWay
-        ) {
-            $this->authorization->skip(function () use ($document, $relatedCollection, $twoWayKey) {
-                $related = $this->findOne($relatedCollection->getId(), [
-                    Query::select(['$id']),
-                    Query::equal($twoWayKey, [$document->getId()])
-                ]);
-
-                if ($related->isEmpty()) {
-                    return;
-                }
-
-                $this->skipRelationships(fn () => $this->updateDocument(
-                    $relatedCollection->getId(),
-                    $related->getId(),
-                    new Document([
-                        $twoWayKey => null
-                    ])
-                ));
-            });
-        }
-
-        if (
-            $relationType === Database::RELATION_MANY_TO_ONE
-            && $side === Database::RELATION_SIDE_CHILD
-        ) {
-            $related = $this->authorization->skip(fn () => $this->findOne($relatedCollection->getId(), [
-                Query::select(['$id']),
-                Query::equal($twoWayKey, [$document->getId()])
-            ]));
-
-            if (!$related->isEmpty()) {
-                throw new RestrictedException('Cannot delete document because it has at least one related document.');
-            }
-        }
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $relatedCollection
-     * @param Document $document
-     * @param mixed $value
-     * @param string $relationType
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @param string $side
-     * @return void
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     * @throws StructureException
-     */
-    private function deleteSetNull(Document $collection, Document $relatedCollection, Document $document, mixed $value, string $relationType, bool $twoWay, string $twoWayKey, string $side): void
-    {
-        switch ($relationType) {
-            case Database::RELATION_ONE_TO_ONE:
-                if (!$twoWay && $side === Database::RELATION_SIDE_PARENT) {
-                    break;
-                }
-
-                // Shouldn't need read or update permission to delete
-                $this->authorization->skip(function () use ($document, $value, $relatedCollection, $twoWay, $twoWayKey, $side) {
-                    if (!$twoWay && $side === Database::RELATION_SIDE_CHILD) {
-                        $related = $this->findOne($relatedCollection->getId(), [
-                            Query::select(['$id']),
-                            Query::equal($twoWayKey, [$document->getId()])
-                        ]);
-                    } else {
-                        if (empty($value)) {
-                            return;
-                        }
-                        $related = $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$id'])]);
-                    }
-
-                    if ($related->isEmpty()) {
-                        return;
-                    }
-
-                    $this->skipRelationships(fn () => $this->updateDocument(
-                        $relatedCollection->getId(),
-                        $related->getId(),
-                        new Document([
-                            $twoWayKey => null
-                        ])
-                    ));
-                });
-                break;
-
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    break;
-                }
-                foreach ($value as $relation) {
-                    $this->authorization->skip(function () use ($relatedCollection, $twoWayKey, $relation) {
-                        $this->skipRelationships(fn () => $this->updateDocument(
-                            $relatedCollection->getId(),
-                            $relation->getId(),
-                            new Document([
-                                $twoWayKey => null
-                            ]),
-                        ));
-                    });
-                }
-                break;
-
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    break;
-                }
-
-                if (!$twoWay) {
-                    $value = $this->find($relatedCollection->getId(), [
-                        Query::select(['$id']),
-                        Query::equal($twoWayKey, [$document->getId()]),
-                        Query::limit(PHP_INT_MAX)
-                    ]);
-                }
-
-                foreach ($value as $relation) {
-                    $this->authorization->skip(function () use ($relatedCollection, $twoWayKey, $relation) {
-                        $this->skipRelationships(fn () => $this->updateDocument(
-                            $relatedCollection->getId(),
-                            $relation->getId(),
-                            new Document([
-                                $twoWayKey => null
-                            ])
-                        ));
-                    });
-                }
-                break;
-
-            case Database::RELATION_MANY_TO_MANY:
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                $junctions = $this->find($junction, [
-                    Query::select(['$id']),
-                    Query::equal($twoWayKey, [$document->getId()]),
-                    Query::limit(PHP_INT_MAX)
-                ]);
-
-                foreach ($junctions as $document) {
-                    $this->skipRelationships(fn () => $this->deleteDocument(
-                        $junction,
-                        $document->getId()
-                    ));
-                }
-                break;
-        }
-    }
-
-    /**
-     * @param Document $collection
-     * @param Document $relatedCollection
-     * @param Document $document
-     * @param string $key
-     * @param mixed $value
-     * @param string $relationType
-     * @param string $twoWayKey
-     * @param string $side
-     * @param Document $relationship
-     * @return void
-     * @throws AuthorizationException
-     * @throws ConflictException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     * @throws StructureException
-     */
-    private function deleteCascade(Document $collection, Document $relatedCollection, Document $document, string $key, mixed $value, string $relationType, string $twoWayKey, string $side, Document $relationship): void
-    {
-        switch ($relationType) {
-            case Database::RELATION_ONE_TO_ONE:
-                if ($value !== null) {
-                    $this->relationshipDeleteStack[] = $relationship;
-
-                    $this->deleteDocument(
-                        $relatedCollection->getId(),
-                        ($value instanceof Document) ? $value->getId() : $value
-                    );
-
-                    \array_pop($this->relationshipDeleteStack);
-                }
-                break;
-            case Database::RELATION_ONE_TO_MANY:
-                if ($side === Database::RELATION_SIDE_CHILD) {
-                    break;
-                }
-
-                $this->relationshipDeleteStack[] = $relationship;
-
-                foreach ($value as $relation) {
-                    $this->deleteDocument(
-                        $relatedCollection->getId(),
-                        $relation->getId()
-                    );
-                }
-
-                \array_pop($this->relationshipDeleteStack);
-
-                break;
-            case Database::RELATION_MANY_TO_ONE:
-                if ($side === Database::RELATION_SIDE_PARENT) {
-                    break;
-                }
-
-                $value = $this->find($relatedCollection->getId(), [
-                    Query::select(['$id']),
-                    Query::equal($twoWayKey, [$document->getId()]),
-                    Query::limit(PHP_INT_MAX),
-                ]);
-
-                $this->relationshipDeleteStack[] = $relationship;
-
-                foreach ($value as $relation) {
-                    $this->deleteDocument(
-                        $relatedCollection->getId(),
-                        $relation->getId()
-                    );
-                }
-
-                \array_pop($this->relationshipDeleteStack);
-
-                break;
-            case Database::RELATION_MANY_TO_MANY:
-                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
-
-                $junctions = $this->skipRelationships(fn () => $this->find($junction, [
-                    Query::select(['$id', $key]),
-                    Query::equal($twoWayKey, [$document->getId()]),
-                    Query::limit(PHP_INT_MAX)
-                ]));
-
-                $this->relationshipDeleteStack[] = $relationship;
-
-                foreach ($junctions as $document) {
-                    if ($side === Database::RELATION_SIDE_PARENT) {
-                        $this->deleteDocument(
-                            $relatedCollection->getId(),
-                            $document->getAttribute($key)
-                        );
-                    }
-                    $this->deleteDocument(
-                        $junction,
-                        $document->getId()
-                    );
-                }
-
-                \array_pop($this->relationshipDeleteStack);
-                break;
-        }
-    }
-
-    /**
-     * Delete Documents
-     *
-     * Deletes all documents which match the given query, will respect the relationship's onDelete optin.
-     *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param int $batchSize
-     * @param (callable(Document, Document): void)|null $onNext
-     * @param (callable(Throwable): void)|null $onError
-     * @return int
-     * @throws AuthorizationException
-     * @throws DatabaseException
-     * @throws RestrictedException
-     * @throws \Throwable
-     */
-    public function deleteDocuments(
-        string $collection,
-        array $queries = [],
-        int $batchSize = self::DELETE_BATCH_SIZE,
-        ?callable $onNext = null,
-        ?callable $onError = null,
-    ): int {
-        if ($this->adapter->getSharedTables() && empty($this->adapter->getTenant())) {
-            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
-        }
-
-        $batchSize = \min(Database::DELETE_BATCH_SIZE, \max(1, $batchSize));
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-        if ($collection->isEmpty()) {
-            throw new DatabaseException('Collection not found');
-        }
-
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $this->authorization->isValid(new Input(self::PERMISSION_DELETE, $collection->getDelete()));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($this->authorization->getDescription());
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
-                $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMaxUIDLength(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForUnsignedBigInt()
-            );
-
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
-        }
-
-        $grouped = Query::groupByType($queries);
-        $limit = $grouped['limit'];
-        $cursor = $grouped['cursor'];
-
-        if (!empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
-            throw new DatabaseException("Cursor document must be from the same Collection.");
-        }
-
-        $originalLimit = $limit;
-        $last = $cursor;
-        $modified = 0;
-
-        while (true) {
-            if ($limit && $limit < $batchSize && $limit > 0) {
-                $batchSize = $limit;
-            } elseif (!empty($limit)) {
-                $limit -= $batchSize;
-            }
-
-            $new = [
-                Query::limit($batchSize)
-            ];
-
-            if (!empty($last)) {
-                $new[] = Query::cursorAfter($last);
-            }
-
-            /**
-             * @var array<Document> $batch
-             */
-            $batch = $this->silent(fn () => $this->find(
-                $collection->getId(),
-                array_merge($new, $queries),
-                forPermission: Database::PERMISSION_DELETE
-            ));
-
-            if (empty($batch)) {
-                break;
-            }
-
-            $old = array_map(fn ($doc) => clone $doc, $batch);
-            $sequences = [];
-            $permissionIds = [];
-
-            $this->withTransaction(function () use ($collection, $sequences, $permissionIds, $batch) {
-                foreach ($batch as $document) {
-                    $sequences[] = $document->getSequence();
-                    if (!empty($document->getPermissions())) {
-                        $permissionIds[] = $document->getId();
-                    }
-
-                    if ($this->resolveRelationships) {
-                        $document = $this->silent(fn () => $this->deleteDocumentRelationships(
-                            $collection,
-                            $document
-                        ));
-                    }
-
-                    // Check if document was updated after the request timestamp
-                    try {
-                        $oldUpdatedAt = new \DateTime($document->getUpdatedAt());
-                    } catch (Exception $e) {
-                        throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
-                    }
-
-                    if (!\is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
-                        throw new ConflictException('Document was updated after the request timestamp');
-                    }
-                }
-
-                $this->adapter->deleteDocuments(
-                    $collection->getId(),
-                    $sequences,
-                    $permissionIds
-                );
-            });
-
-            foreach ($batch as $index => $document) {
-                $this->withDocumentTenant($document, fn () => $this->purgeCachedDocument($collection->getId(), $document->getId()));
-                try {
-                    $onNext && $onNext($document, $old[$index]);
-                } catch (Throwable $th) {
-                    $onError ? $onError($th) : throw $th;
-                }
-                $modified++;
-            }
-
-            if (count($batch) < $batchSize) {
-                break;
-            } elseif ($originalLimit && $modified >= $originalLimit) {
-                break;
-            }
-
-            $last = \end($batch);
-        }
-
-        $this->trigger(self::EVENT_DOCUMENTS_DELETE, new Document([
-            '$collection' => $collection->getId(),
-            'modified' => $modified
-        ]));
-
-        return $modified;
-    }
-
-    /**
-     * Cleans the all the collection's documents from the cache
-     * And the all related cached documents.
-     *
-     * @param string $collectionId
-     *
-     * @return bool
-     */
-    public function purgeCachedCollection(string $collectionId): bool
-    {
-        [$collectionKey] = $this->getCacheKeys($collectionId);
-
-        $documentKeys = $this->cache->list($collectionKey);
-        foreach ($documentKeys as $documentKey) {
-            $this->cache->purge($documentKey);
-        }
-
-        $this->cache->purge($collectionKey);
-
-        return true;
-    }
-
-    /**
-     * Cleans a specific document from cache
-     * And related document reference in the collection cache.
-     *
-     * @param string $collectionId
-     * @param string|null $id
-     * @return bool
-     * @throws Exception
-     */
-    protected function purgeCachedDocumentInternal(string $collectionId, ?string $id): bool
-    {
-        if ($id === null) {
-            return true;
-        }
-
-        [$collectionKey, $documentKey] = $this->getCacheKeys($collectionId, $id);
-
-        $this->cache->purge($collectionKey, $documentKey);
-        $this->cache->purge($documentKey);
-
-        return true;
-    }
-
-    /**
-     * Run a per-document cache operation under the document's own tenant.
-     *
-     * With tenant-per-document, cache keys are scoped by the adapter's current
-     * tenant, so a document's purge must run under that document's tenant to
-     * target the right key; otherwise the callback runs as-is.
-     *
-     * @param Document $document
-     * @param callable():mixed $callback
-     * @return void
-     * @throws Exception
-     */
-    private function withDocumentTenant(Document $document, callable $callback): void
-    {
-        if ($this->getSharedTables() && $this->getTenantPerDocument()) {
-            $this->withTenant($document->getTenant(), $callback);
-        } else {
-            $callback();
-        }
-    }
-
-    /**
-     * Cleans a specific document from cache and triggers EVENT_DOCUMENT_PURGE.
-     * And related document reference in the collection cache.
-     *
-     * Note: Do not retry this method as it triggers events. Use purgeCachedDocumentInternal() with retry instead.
-     *
-     * @param string $collectionId
-     * @param string|null $id
-     * @return bool
-     * @throws Exception
-     */
-    public function purgeCachedDocument(string $collectionId, ?string $id): bool
-    {
-        $result = $this->purgeCachedDocumentInternal($collectionId, $id);
-
-        if ($id !== null) {
-            $this->trigger(self::EVENT_DOCUMENT_PURGE, new Document([
-                '$id' => $id,
-                '$collection' => $collectionId
-            ]));
-        }
-
-        return $result;
-    }
-
-    /**
-     * Find Documents
-     *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return array<Document>
-     * @throws DatabaseException
-     * @throws QueryException
-     * @throws TimeoutException
-     * @throws Exception
-     */
-    public function find(string $collection, array $queries = [], string $forPermission = Database::PERMISSION_READ): array
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
-                $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMaxUIDLength(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForUnsignedBigInt()
-            );
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
-        }
-
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $this->authorization->isValid(new Input($forPermission, $collection->getPermissionsByType($forPermission)));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($this->authorization->getDescription());
-        }
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
-        );
-
-        $grouped = Query::groupByType($queries);
-        $filters = $grouped['filters'];
-        $selects = $grouped['selections'];
-        $limit = $grouped['limit'];
-        $offset = $grouped['offset'];
-        $orderAttributes = $grouped['orderAttributes'];
-        $orderTypes = $grouped['orderTypes'];
-        $cursor = $grouped['cursor'];
-        $cursorDirection = $grouped['cursorDirection'] ?? Database::CURSOR_AFTER;
-
-        $uniqueOrderBy = false;
-        foreach ($orderAttributes as $order) {
-            if ($order === '$id' || $order === '$sequence') {
-                $uniqueOrderBy = true;
-            }
-        }
-
-        $vectorSearch = false;
-        foreach ($filters as $filter) {
-            if (\in_array($filter->getMethod(), Query::VECTOR_TYPES)) {
-                $vectorSearch = true;
-                break;
-            }
-        }
-
-        // A vector search is ordered by distance, and a vector index can only answer that one
-        // sort key. Appending a tie break makes the ordering unsatisfiable from the index and
-        // costs a full scan of the collection. The tie break exists to hold a page boundary
-        // still, so it is only owed to a cursor.
-        if ($uniqueOrderBy === false && (!$vectorSearch || !empty($cursor))) {
-            $leadingAttribute = $orderAttributes[0] ?? null;
-            $leadingOrderType = $orderTypes[0] ?? Database::ORDER_ASC;
-
-            if (\in_array($leadingAttribute, ['$createdAt', '$updatedAt'], true)) {
-                $orderAttributes[] = '$sequence';
-                $orderTypes[] = $leadingOrderType;
-            } else {
-                $orderAttributes[] = '$sequence';
-                $orderTypes[] = Database::ORDER_ASC;
-            }
-        }
-
-        if (!empty($cursor)) {
-            foreach ($orderAttributes as $order) {
-                if ($cursor->getAttribute($order) === null) {
-                    throw new OrderException(
-                        message: "Order attribute '{$order}' is empty",
-                        attribute: $order
-                    );
-                }
-            }
-        }
-
-        if (!empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
-            throw new DatabaseException("cursor Document must be from the same Collection.");
-        }
-
-        if (!empty($cursor)) {
-            $cursor = $this->encode($collection, $cursor);
-            $cursor = $this->adapter->castingBefore($collection, $cursor);
-            $cursor = $cursor->getArrayCopy();
-        } else {
-            $cursor = [];
-        }
-
-        /**  @var array<Query> $queries */
-        $queries = \array_merge(
-            $selects,
-            $this->convertQueries($collection, $filters)
-        );
-
-        $selections = $this->validateSelections($collection, $selects);
-        $nestedSelections = $this->processRelationshipQueries($relationships, $queries);
-
-        // Convert relationship filter queries to SQL-level subqueries
-        $queriesOrNull = $this->convertRelationshipQueries($relationships, $queries, $collection);
-
-        // If conversion returns null, it means no documents can match (relationship filter found no matches)
-        if ($queriesOrNull === null) {
-            $results = [];
-        } else {
-            $queries = $queriesOrNull;
-
-            $getResults = fn () => $this->adapter->find(
-                $collection,
-                $queries,
-                $limit ?? 25,
-                $offset ?? 0,
-                $orderAttributes,
-                $orderTypes,
-                $cursor,
-                $cursorDirection,
-                $forPermission
-            );
-
-            $results = $skipAuth ? $this->authorization->skip($getResults) : $getResults();
-        }
-
-        if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships && !empty($relationships) && (empty($selects) || !empty($nestedSelections))) {
-            if (count($results) > 0) {
-                $results = $this->silent(fn () => $this->populateDocumentsRelationships($results, $collection, $this->relationshipFetchDepth, $nestedSelections));
-            }
-        }
-
-        foreach ($results as $index => $node) {
-            $node = $this->adapter->castingAfter($collection, $node);
-            $node = $this->casting($collection, $node);
-            $node = $this->decode($collection, $node, $selections);
-
-            // Convert to custom document type if mapped
-            if (isset($this->documentTypes[$collection->getId()])) {
-                $node = $this->createDocumentInstance($collection->getId(), $node->getArrayCopy());
-            }
-
-            if (!$node->isEmpty()) {
-                $node->setAttribute('$collection', $collection->getId());
-            }
-
-            $results[$index] = $node;
-        }
-
-        $this->trigger(self::EVENT_DOCUMENT_FIND, $results);
-
-        return $results;
-    }
-
-    /**
-     * Purge all cached query entries for a collection namespace.
-     *
-     * @param string $collection
-     * @param string|null $namespace
-     * @return bool
-     */
-    public function purgeCachedQueries(string $collection, ?string $namespace = null): bool
-    {
-        $collectionDocument = $this->silent(fn () => $this->getCollection($collection));
-        $collection = $collectionDocument->isEmpty() ? $collection : $collectionDocument->getId();
-
-        return $this->cache->purge(
-            $this->getQueryCacheKey($collection, $namespace)
-        );
-    }
-
-    /**
-     * Execute a callback behind a cache-aside lookup.
-     *
-     * The callback runs on cache miss and its value is returned to the caller.
-     * Query document payloads are converted to arrays before save and restored
-     * back into Documents on cache hits. A rejected document payload refreshes
-     * the cached value.
-     * A literal false value is treated as a cache miss and is not cacheable.
-     *
-     * @template T
-     * @param string $key
-     * @param callable(): T $callback
-     * @param string|null $hash
-     * @return T
-     * @throws AuthorizationException
-     * @throws Exception
-     */
-    public function withCache(
-        string $key,
-        callable $callback,
-        ?string $hash = '',
-    ): mixed {
-        if ($hash === null) {
-            return $callback();
-        }
-
-        $shouldRefreshCache = false;
-
-        try {
-            $cached = $this->cache->load($key, self::TTL, $hash);
-        } catch (Throwable $e) {
-            Console::warning('Warning: Failed to load cache value: ' . $e->getMessage());
-            $cached = false;
-        }
-
-        if ($cached !== false && $cached !== null) {
-            $cachedValue = \is_array($cached) && \array_key_exists('value', $cached) ? $cached['value'] : false;
-
-            if ($cachedValue !== false) {
-                $decoded = $cachedValue;
-                $collection = $cached['collection'] ?? null;
-
-                if (\is_string($collection) && $collection !== '') {
-                    // Cached document payloads are stored as arrays; restore them
-                    // to the same Document shape that find()/getDocument() return.
-                    $collection = $this->silent(fn () => $this->getCollection($collection));
-
-                    if ($collection->isEmpty()) {
-                        $decoded = false;
-                    } else {
-                        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-                        $skipAuth = $this->authorization->isValid(new Input(self::PERMISSION_READ, $collection->getRead()));
-
-                        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-                            throw new AuthorizationException($this->authorization->getDescription());
-                        }
-
-                        $payload = ($cached['type'] ?? null) === 'document' ? [$cachedValue] : $cachedValue;
-
-                        if (!\is_array($payload)) {
-                            $decoded = false;
-                        } else {
-                            $documents = [];
-
-                            foreach ($payload as $document) {
-                                if (!\is_array($document)) {
-                                    $decoded = false;
-                                    break;
-                                }
-
-                                $document = $this->createDocumentInstance($collection->getId(), $document);
-                                $document = $this->casting($collection, $document);
-
-                                if ($this->isTtlExpired($collection, $document)) {
-                                    $decoded = false;
-                                    break;
-                                }
-
-                                if (!$skipAuth && $documentSecurity && $collection->getId() !== self::METADATA) {
-                                    if (!$this->authorization->isValid(new Input(self::PERMISSION_READ, $document->getRead()))) {
-                                        if (($cached['type'] ?? null) === 'document') {
-                                            $decoded = false;
-                                            break;
-                                        }
-
-                                        continue;
-                                    }
-                                }
-
-                                $documents[] = $document;
-                            }
-
-                            if ($decoded !== false) {
-                                $decoded = ($cached['type'] ?? null) === 'document' ? ($documents[0] ?? false) : $documents;
-                            }
-                        }
-                    }
-                }
-
-                if ($decoded !== false) {
-                    return $decoded;
-                }
-            }
-
-            $shouldRefreshCache = true;
-        }
-
-        if ($shouldRefreshCache) {
-            try {
-                $this->cache->purge($key, $hash);
-            } catch (Throwable $e) {
-                Console::warning('Warning: Failed to purge rejected cache value: ' . $e->getMessage());
-            }
-        }
-
-        // Capture the generation before the callback runs its read: if a
-        // concurrent write purges this query key in between, saveWithLease()
-        // below rejects the now-stale list instead of re-poisoning the cache.
-        $generation = '0';
-        try {
-            $generation = $this->cache->getGeneration($key);
-        } catch (Throwable $e) {
-            Console::warning('Warning: Failed to get cache generation: ' . $e->getMessage());
-        }
-
-        $callbackValue = $callback();
+        if (empty($filters)) {
+            $initial = $this->filter;
+            $this->disableFilters();
 
-        if ($callbackValue !== false) {
             try {
-                $encoded = false;
-
-                if ($callbackValue instanceof Document) {
-                    $collection = $callbackValue->getCollection();
-
-                    if ($collection !== '') {
-                        $encoded = [
-                            'collection' => $collection,
-                            'type' => 'document',
-                            'value' => $callbackValue->getArrayCopy(),
-                        ];
-                    }
-                } elseif (!\is_array($callbackValue)) {
-                    $encoded = ['value' => $callbackValue];
-                } else {
-                    // Only homogeneous top-level document lists are safe to restore
-                    // from cache. Plain arrays containing Documents are left uncached.
-                    $collection = null;
-                    $hasDocuments = false;
-                    $hasNonDocuments = false;
-                    $cacheable = true;
-                    $documents = [];
-                    $containsDocument = function (mixed $item) use (&$containsDocument): bool {
-                        if ($item instanceof Document) {
-                            return true;
-                        }
-
-                        if (!\is_array($item)) {
-                            return false;
-                        }
-
-                        foreach ($item as $child) {
-                            if ($containsDocument($child)) {
-                                return true;
-                            }
-                        }
-
-                        return false;
-                    };
-
-                    foreach ($callbackValue as $item) {
-                        if (!$item instanceof Document) {
-                            if ($hasDocuments || $containsDocument($item)) {
-                                $cacheable = false;
-                                break;
-                            }
-
-                            $hasNonDocuments = true;
-                            continue;
-                        }
-
-                        if ($hasNonDocuments) {
-                            $cacheable = false;
-                            break;
-                        }
-
-                        $documentCollection = $item->getCollection();
-                        if ($documentCollection === '') {
-                            $cacheable = false;
-                            break;
-                        }
-
-                        if ($collection !== null && $collection !== $documentCollection) {
-                            $cacheable = false;
-                            break;
-                        }
-
-                        $collection = $documentCollection;
-                        $hasDocuments = true;
-                        $documents[] = $item->getArrayCopy();
-                    }
-
-                    if ($cacheable) {
-                        $encoded = $hasDocuments ? [
-                            'collection' => $collection,
-                            'type' => 'documents',
-                            'value' => $documents,
-                        ] : ['value' => $callbackValue];
-                    }
-                }
-
-                if ($encoded !== false) {
-                    $this->cache->saveWithLease($key, $encoded, $hash, $generation);
-                }
-            } catch (Throwable $e) {
-                Console::warning('Warning: Failed to save cache value: ' . $e->getMessage());
-            }
-        }
-
-        /** @var T $callbackValue */
-        return $callbackValue;
-    }
-
-    /**
-     * Helper method to iterate documents in collection using callback pattern
-     * Alterative is
-     *
-     * @param string $collection
-     * @param callable $callback
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return void
-     * @throws \Utopia\Database\Exception
-     */
-    public function foreach(string $collection, callable $callback, array $queries = [], string $forPermission = Database::PERMISSION_READ): void
-    {
-        foreach ($this->iterate($collection, $queries, $forPermission) as $document) {
-            $callback($document);
-        }
-    }
-
-    /**
-     * Return each document of the given collection
-     * that matches the given queries
-     *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return \Generator
-     * @throws \Utopia\Database\Exception
-     */
-    public function iterate(string $collection, array $queries = [], string $forPermission = Database::PERMISSION_READ): \Generator
-    {
-        $grouped = Query::groupByType($queries);
-        $limitExists = $grouped['limit'] !== null;
-        $limit = $grouped['limit'] ?? 25;
-        $offset = $grouped['offset'];
-
-        $cursor = $grouped['cursor'];
-        $cursorDirection = $grouped['cursorDirection'];
-
-        // Cursor before is not supported
-        if ($cursor !== null && $cursorDirection === Database::CURSOR_BEFORE) {
-            throw new DatabaseException('Cursor ' . Database::CURSOR_BEFORE . ' not supported in this method.');
-        }
-
-        $sum = $limit;
-        $latestDocument = null;
-
-        while ($sum === $limit) {
-            $newQueries = $queries;
-            if ($latestDocument !== null) {
-                //reset offset and cursor as groupByType ignores same type query after first one is encountered
-                if ($offset !== null) {
-                    array_unshift($newQueries, Query::offset(0));
-                }
-
-                array_unshift($newQueries, Query::cursorAfter($latestDocument));
-            }
-            if (!$limitExists) {
-                $newQueries[] = Query::limit($limit);
-            }
-            $results = $this->find($collection, $newQueries, $forPermission);
-
-            if (empty($results)) {
-                return;
-            }
-
-            $sum = count($results);
-
-            foreach ($results as $document) {
-                yield $document;
-            }
-
-            $latestDocument = $results[array_key_last($results)];
-        }
-    }
-
-    /**
-     * @param string $collection
-     * @param array<Query> $queries
-     * @return Document
-     * @throws DatabaseException
-     */
-    public function findOne(string $collection, array $queries = []): Document
-    {
-        $results = $this->silent(fn () => $this->find($collection, \array_merge([
-            Query::limit(1)
-        ], $queries)));
-
-        $found = \reset($results);
-
-        $this->trigger(self::EVENT_DOCUMENT_FIND, $found);
-
-        if (!$found) {
-            return new Document();
-        }
-
-        return $found;
-    }
-
-    /**
-     * Count Documents
-     *
-     * Count the number of documents.
-     *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param int|null $max
-     *
-     * @return int
-     * @throws DatabaseException
-     */
-    public function count(string $collection, array $queries = [], ?int $max = null): int
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
-                $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMaxUIDLength(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForUnsignedBigInt()
-            );
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
-        }
-
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $this->authorization->isValid(new Input(self::PERMISSION_READ, $collection->getRead()));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($this->authorization->getDescription());
-        }
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
-        );
-
-        $queries = Query::groupByType($queries)['filters'];
-        $queries = $this->convertQueries($collection, $queries);
-
-        $queriesOrNull = $this->convertRelationshipQueries($relationships, $queries, $collection);
-
-        if ($queriesOrNull === null) {
-            return 0;
-        }
-
-        $queries = $queriesOrNull;
-
-        $getCount = fn () => $this->adapter->count($collection, $queries, $max);
-        $count = $skipAuth ? $this->authorization->skip($getCount) : $getCount();
-
-        $this->trigger(self::EVENT_DOCUMENT_COUNT, $count);
-
-        return $count;
-    }
-
-    /**
-     * Sum an attribute
-     *
-     * Sum an attribute for all the documents. Pass $max=0 for unlimited count
-     *
-     * @param string $collection
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @param int|null $max
-     *
-     * @return int|float
-     * @throws DatabaseException
-     */
-    public function sum(string $collection, string $attribute, array $queries = [], ?int $max = null): float|int
-    {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
-
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
-
-        $this->checkQueryTypes($queries);
-
-        if ($this->validate) {
-            $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
-                $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMaxUIDLength(),
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
-                $this->adapter->getSupportForAttributes(),
-                $this->adapter->getSupportForUnsignedBigInt()
-            );
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
+                return $callback();
+            } finally {
+                $this->filter = $initial;
             }
         }
 
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $this->authorization->isValid(new Input(self::PERMISSION_READ, $collection->getRead()));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($this->authorization->getDescription());
+        $previous = $this->filter;
+        $previousDisabled = $this->disabledFilters;
+        $disabled = [];
+        foreach ($filters as $name) {
+            $disabled[$name] = true;
         }
+        $this->disabledFilters = $disabled;
 
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
-        );
-
-        $queries = $this->convertQueries($collection, $queries);
-        $queriesOrNull = $this->convertRelationshipQueries($relationships, $queries, $collection);
-
-        // If conversion returns null, it means no documents can match (relationship filter found no matches)
-        if ($queriesOrNull === null) {
-            return 0;
+        try {
+            return $callback();
+        } finally {
+            $this->filter = $previous;
+            $this->disabledFilters = $previousDisabled;
         }
-
-        $queries = $queriesOrNull;
-
-        $getSum = fn () => $this->adapter->sum($collection, $attribute, $queries, $max);
-        $sum = $skipAuth ? $this->authorization->skip($getSum) : $getSum();
-
-        $this->trigger(self::EVENT_DOCUMENT_SUM, $sum);
-
-        return $sum;
     }
 
     /**
-     * Add Attribute Filter
-     *
-     * @param string $name
-     * @param callable $encode
-     * @param callable $decode
-     *
-     * @return void
-     */
-    public static function addFilter(string $name, callable $encode, callable $decode): void
-    {
-        self::$filters[$name] = [
-            'encode' => $encode,
-            'decode' => $decode,
-            'signature' => self::computeCallableSignature($encode) . ':' . self::computeCallableSignature($decode),
-        ];
-    }
-
-    /**
-     * Remove attributes the collection schema does not declare.
-     *
-     * Used ahead of change detection on update/upsert so a dropped key is not
-     * counted as a write. Encode also calls this after iterating attributes.
-     *
-     * @param Document $collection
-     * @param Document $document
-     * @param array<string, true>|null $known Attribute ids already collected (e.g. during encode)
+     * Get instance filters
      *
-     * @return Document
+     * @return array<string, array{encode: callable, decode: callable, signature: string}>
      */
-    protected function removeUnknownAttributes(Document $collection, Document $document, ?array $known = null): Document
+    public function getInstanceFilters(): array
     {
-        if (!$this->dropUnknownAttributes || !$this->adapter->getSupportForAttributes()) {
-            return $document;
-        }
-
-        if ($known === null) {
-            $known = [];
-            foreach ($collection->getAttribute('attributes', []) as $attribute) {
-                $known[$attribute['$id'] ?? ''] = true;
-            }
-        }
-
-        $dropped = [];
-        foreach (\array_keys($document->getArrayCopy()) as $key) {
-            if (\str_starts_with($key, '$') || isset($known[$key])) {
-                continue;
-            }
-
-            $dropped[] = $key;
-            $document->removeAttribute($key);
-        }
-
-        if (!empty($dropped)) {
-            Console::warning(
-                'Dropped unknown attributes "' . \implode('", "', $dropped) . '" from collection "' . $collection->getId() . '"'
-                . ($this->adapter->getTenant() === null ? '' : ' on tenant ' . $this->adapter->getTenant())
-            );
-        }
-
-        return $document;
+        return $this->instanceFilters;
     }
 
     /**
      * Encode Document
      *
-     * When dropUnknownAttributes is enabled, attributes missing from the
-     * collection schema are removed here while the known set is collected.
+     * @param  bool  $applyDefaults  Whether to apply default values to null attributes
      *
-     * @param Document $collection
-     * @param Document $document
-     * @param bool $applyDefaults Whether to apply default values to null attributes
-     *
-     * @return Document
      * @throws DatabaseException
      */
     public function encode(Document $collection, Document $document, bool $applyDefaults = true): Document
     {
-        $attributes = $collection->getAttribute('attributes', []);
-        $internalDateAttributes = ['$createdAt', '$updatedAt'];
+        $rawAttributes = $collection->getAttribute('attributes', []);
+        $attributes = \is_array($rawAttributes) ? $rawAttributes : [];
+        $internalDateAttributes = [Document::CREATED_AT, Document::UPDATED_AT];
         foreach ($this->getInternalAttributes() as $attribute) {
             $attributes[] = $attribute;
         }
 
         $known = [];
+
         foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
+            if ($attribute instanceof Attribute) {
+                $key = $attribute->key;
+                $array = $attribute->array;
+                $default = $attribute->default;
+                $filters = $attribute->filters;
+            } elseif ($attribute instanceof Document) {
+                $key = $attribute->getId();
+                $array = (bool) $attribute->getAttribute('array', false);
+                $default = $attribute->offsetExists('default') ? $attribute['default'] : null;
+                $filters = $attribute->getArray('filters');
+            } elseif (\is_array($attribute)) {
+                $key = \is_string($attribute[Document::ID] ?? null) ? $attribute[Document::ID] : '';
+                $array = $attribute['array'] ?? false;
+                $default = $attribute['default'] ?? null;
+                $filters = \is_array($attribute['filters'] ?? null) ? $attribute['filters'] : [];
+            } else {
+                continue;
+            }
             $known[$key] = true;
-            $array = $attribute['array'] ?? false;
-            $default = $attribute['default'] ?? null;
-            $filters = $attribute['filters'] ?? [];
-            $value = $document->getAttribute($key);
+            /** @var array<string> $filters */
+            $exists = $document->offsetExists($key);
+            $value = $exists ? $document[$key] : null;
 
             if (in_array($key, $internalDateAttributes) && is_string($value) && empty($value)) {
                 $document->setAttribute($key, null);
+
                 continue;
             }
 
-            if ($key === '$permissions') {
+            if ($key === Document::PERMISSIONS) {
                 continue;
             }
 
             // Continue on optional param with no default
-            if (is_null($value) && is_null($default)) {
+            if (! $exists && $default === null) {
                 continue;
             }
 
@@ -9354,11 +1610,9 @@ public function encode(Document $collection, Document $document, bool $applyDefa
             }
 
             // Assign default only if no value provided
-            // False positive "Call to function is_null() with mixed will always evaluate to false"
-            // @phpstan-ignore-next-line
-            if (is_null($value) && !is_null($default)) {
+            if (! $exists) {
                 // Skip applying defaults during updates to avoid resetting unspecified attributes
-                if (!$applyDefaults) {
+                if (! $applyDefaults) {
                     continue;
                 }
                 $value = ($array) ? $default : [$default];
@@ -9366,6 +1620,7 @@ public function encode(Document $collection, Document $document, bool $applyDefa
                 $value = ($array) ? $value : [$value];
             }
 
+            /** @var array<int|string, mixed> $value */
             foreach ($value as $index => $node) {
                 if ($node !== null) {
                     foreach ($filters as $filter) {
@@ -9375,49 +1630,107 @@ public function encode(Document $collection, Document $document, bool $applyDefa
                 }
             }
 
-            if (!$array) {
-                $value = $value[0];
-            }
-            $document->setAttribute($key, $value);
+            if (! $array) {
+                $value = $value[0];
+            }
+            $document->setAttribute($key, $value);
+        }
+
+        return $this->removeUnknownAttributes($collection, $document, $known);
+    }
+
+    /**
+     * Remove attributes the collection schema does not declare.
+     *
+     * Used ahead of change detection on update and upsert so a dropped key is not
+     * counted as a write. encode() also calls this once it has collected the known
+     * set while iterating the schema.
+     *
+     * @param  array<string, true>|null  $known  Attribute ids already collected
+     */
+    protected function removeUnknownAttributes(Document $collection, Document $document, ?array $known = null): Document
+    {
+        if (! $this->dropUnknownAttributes || ! $this->adapter->supports(Capability::DefinedAttributes)) {
+            return $document;
+        }
+
+        if ($known === null) {
+            $known = [];
+            $declared = $collection->getAttribute('attributes', []);
+            foreach (\is_array($declared) ? $declared : [] as $attribute) {
+                $key = match (true) {
+                    $attribute instanceof Attribute => $attribute->key,
+                    $attribute instanceof Document => $attribute->getId(),
+                    \is_array($attribute) => \is_string($attribute[Document::ID] ?? null) ? $attribute[Document::ID] : '',
+                    default => '',
+                };
+                $known[$key] = true;
+            }
+        }
+
+        $dropped = [];
+        foreach (\array_keys($document->getArrayCopy()) as $key) {
+            if (\str_starts_with((string) $key, '$') || isset($known[$key])) {
+                continue;
+            }
+
+            $dropped[] = $key;
+            $document->removeAttribute((string) $key);
         }
 
-        return $this->removeUnknownAttributes($collection, $document, $known);
+        if (! empty($dropped)) {
+            Console::warning(
+                'Dropped unknown attributes "'.\implode('", "', $dropped).'" from collection "'.$collection->getId().'"'
+                .($this->adapter->getTenant() === null ? '' : ' on tenant '.$this->adapter->getTenant())
+            );
+        }
+
+        return $document;
     }
 
     /**
      * Decode Document
      *
-     * @param Document $collection
-     * @param Document $document
-     * @param array<string> $selections
-     * @return Document
+     * @param  array<string>  $selections
+     *
      * @throws DatabaseException
      */
     public function decode(Document $collection, Document $document, array $selections = []): Document
     {
-        $attributes = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn ($attribute) => $attribute['type'] !== self::VAR_RELATIONSHIP
-        );
-
-        $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn ($attribute) => $attribute['type'] === self::VAR_RELATIONSHIP
-        );
+        /** @var array<array<string, mixed>|Document> $allAttributes */
+        $allAttributes = $collection->getAttribute('attributes', []);
+
+        // Single-pass partition into relationships vs regular attributes.
+        // Replaces two array_filter passes that each walked the full list.
+        $attributes = [];
+        $relationships = [];
+        $relationshipType = ColumnType::Relationship->value;
+        foreach ($allAttributes as $attribute) {
+            if (($attribute['type'] ?? '') === $relationshipType) {
+                $relationships[] = $attribute;
+            } else {
+                $attributes[] = $attribute;
+            }
+        }
 
         $filteredValue = [];
 
-        foreach ($relationships as $relationship) {
-            $key = $relationship['$id'] ?? '';
-
-            if (
-                \array_key_exists($key, (array)$document)
-                || \array_key_exists($this->adapter->filter($key), (array)$document)
-            ) {
-                $value = $document->getAttribute($key);
-                $value ??= $document->getAttribute($this->adapter->filter($key));
-                $document->removeAttribute($this->adapter->filter($key));
-                $document->setAttribute($key, $value);
+        if (! empty($relationships)) {
+            $documentArray = (array) $document;
+            foreach ($relationships as $relationship) {
+                /** @var string $key */
+                $key = $relationship[Document::ID] ?? '';
+                $filteredKey = $this->adapter->filter($key);
+
+                if (
+                    \array_key_exists($key, $documentArray)
+                    || \array_key_exists($filteredKey, $documentArray)
+                ) {
+                    $value = $document->getAttribute($key);
+                    $value ??= $document->getAttribute($filteredKey);
+                    $document->removeAttribute($filteredKey);
+                    $document->setAttribute($key, $value);
+                }
             }
         }
 
@@ -9425,34 +1738,39 @@ public function decode(Document $collection, Document $document, array $selectio
             $attributes[] = $attribute;
         }
 
+        $hasSelections = ! empty($selections);
+        $selectAll = $hasSelections && \in_array('*', $selections, true);
+        $selectionsMap = ($hasSelections && ! $selectAll)
+            ? \array_fill_keys($selections, true)
+            : null;
+
         $hasRelationshipSelections = false;
-        foreach ($selections as $selection) {
-            if (\str_contains($selection, '.')) {
-                $hasRelationshipSelections = true;
-                break;
+        if ($selectionsMap !== null) {
+            foreach ($selections as $selection) {
+                if (\str_contains($selection, '.')) {
+                    $hasRelationshipSelections = true;
+                    break;
+                }
             }
         }
 
         foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            $type = $attribute['type'] ?? '';
+            /** @var string $key */
+            $key = $attribute[Document::ID] ?? '';
+            if ($key === Document::PERMISSIONS) {
+                continue;
+            }
+
             $array = $attribute['array'] ?? false;
+            /** @var array<string> $filters */
             $filters = $attribute['filters'] ?? [];
             $value = $document->getAttribute($key);
 
-            if ($key === '$permissions') {
-                continue;
-            }
-
             if (\is_null($value)) {
                 $filteredKey = $this->adapter->filter($key);
                 $value = $document->getAttribute($filteredKey);
 
-                if (!\is_null($value)) {
-                    $document->removeAttribute($filteredKey);
-                } elseif ($filteredKey !== $key && $document->offsetExists($filteredKey)) {
-                    // SQL adapter column names use filter($key); remove the alias so the
-                    // in-memory document only exposes keys (e.g. "a.b") that match the schema.
+                if (! \is_null($value)) {
                     $document->removeAttribute($filteredKey);
                 }
             }
@@ -9465,109 +1783,135 @@ public function decode(Document $collection, Document $document, array $selectio
             $value = ($array) ? $value : [$value];
             $value = (is_null($value)) ? [] : $value;
 
-            $selected = empty($selections)
-                || \in_array($key, $selections)
-                || \in_array('*', $selections);
+            /** @var array<int|string, mixed> $value */
+            $selected = ! $hasSelections
+                || $selectAll
+                || ($selectionsMap !== null && isset($selectionsMap[$key]));
 
-            if ($selected || $hasRelationshipSelections) {
+            $filterCount = \count($filters);
+
+            if ($filterCount > 0 && ($selected || $hasRelationshipSelections)) {
                 foreach ($value as $index => $node) {
-                    foreach (\array_reverse($filters) as $filter) {
-                        $node = $this->decodeAttribute($filter, $node, $document, $key);
+                    for ($i = $filterCount - 1; $i >= 0; $i--) {
+                        $node = $this->decodeAttribute($filters[$i], $node, $document, $key);
                     }
                     $value[$index] = $node;
                 }
             }
 
-            $filteredValue[$key] = ($array) ? $value : $value[0];
+            $resolved = $array ? $value : $value[0];
+            $filteredValue[$key] = $resolved;
 
             if ($selected) {
-                $document->setAttribute($key, ($array) ? $value : $value[0]);
+                $document->setAttribute($key, $resolved);
             }
         }
 
-        if ($hasRelationshipSelections && !empty($selections) && !\in_array('*', $selections)) {
-            foreach ($collection->getAttribute('attributes', []) as $attribute) {
-                $key = $attribute['$id'] ?? '';
+        if ($hasRelationshipSelections && $selectionsMap !== null) {
+            foreach ($allAttributes as $attribute) {
+                /** @var string $key */
+                $key = $attribute[Document::ID] ?? '';
 
-                if ($attribute['type'] === self::VAR_RELATIONSHIP || $key === '$permissions') {
+                if (($attribute['type'] ?? '') === $relationshipType || $key === Document::PERMISSIONS) {
                     continue;
                 }
 
-                if (!in_array($key, $selections) && isset($filteredValue[$key])) {
+                if (! isset($selectionsMap[$key]) && isset($filteredValue[$key])) {
                     $document->setAttribute($key, $filteredValue[$key]);
                 }
             }
         }
+
         return $document;
     }
 
     /**
-     * Casting
+     * Cast document attribute values to their proper PHP types based on the collection schema.
      *
-     * @param Document $collection
-     * @param Document $document
-     *
-     * @return Document
+     * @param Document $collection The collection definition containing attribute type information.
+     * @param Document $document The document whose attributes will be cast.
+     * @return Document The document with correctly typed attribute values.
      */
     public function casting(Document $collection, Document $document): Document
     {
-        if (!$this->adapter->getSupportForCasting()) {
+        if (! $this->adapter->supports(Capability::Casting)) {
             return $document;
         }
 
+        /** @var array<array<string, mixed>> $attributes */
         $attributes = $collection->getAttribute('attributes', []);
 
         foreach ($this->getInternalAttributes() as $attribute) {
             $attributes[] = $attribute;
         }
 
+        // Cache the set of types that actually require a cast. Strings,
+        // datetimes, JSON, etc. all fall through to default in the match
+        // below, so skipping them entirely avoids the per-attribute
+        // foreach + setAttribute pair on every document.
+        $idType = ColumnType::Id->value;
+        $boolType = ColumnType::Boolean->value;
+        $intType = ColumnType::Integer->value;
+        $bigIntType = ColumnType::BigInteger->value;
+        $bigSerialType = ColumnType::BigSerial->value;
+        $floatType = ColumnType::Float->value;
+        $doubleType = ColumnType::Double->value;
+
         foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
+            /** @var string $key */
+            $key = $attribute[Document::ID] ?? '';
+            if ($key === Document::PERMISSIONS) {
+                continue;
+            }
+
             $type = $attribute['type'] ?? '';
-            $signed = $attribute['signed'] ?? true;
+            $signed = (bool) ($attribute['signed'] ?? true);
             $array = $attribute['array'] ?? false;
-            $value = $document->getAttribute($key, null);
-            if (is_null($value)) {
+            $normalizedType = $type instanceof ColumnType || \is_string($type)
+                ? Attribute::tryNormalizeType($type)
+                : null;
+            $typeKey = $normalizedType instanceof ColumnType ? $normalizedType->value : '';
+
+            $needsCast = $array
+                || $typeKey === $idType
+                || $typeKey === $boolType
+                || $typeKey === $intType
+                || $typeKey === $bigIntType
+                || $typeKey === $bigSerialType
+                || $typeKey === $floatType
+                || $typeKey === $doubleType;
+            if (! $needsCast) {
+                // String/datetime/JSON/etc — already in their canonical
+                // PHP type after PDO fetch. Skip the load/setAttribute
+                // round trip entirely.
                 continue;
             }
 
-            if ($key === '$permissions') {
+            $value = $document->getAttribute($key, null);
+            if (\is_null($value)) {
                 continue;
             }
 
             if ($array) {
-                $value = !is_string($value)
+                $value = ! \is_string($value)
                     ? $value
-                    : json_decode($value, true);
+                    : \json_decode($value, true);
             } else {
                 $value = [$value];
             }
 
+            /** @var array<int|string, scalar|null> $value */
             foreach ($value as $index => $node) {
-                switch ($type) {
-                    case self::VAR_ID:
-                        // Disabled until Appwrite migrates to use real int ID's for MySQL
-                        //$type = $this->adapter->getIdAttributeType();
-                        //\settype($node, $type);
-                        $node = (string)$node;
-                        break;
-                    case self::VAR_BOOLEAN:
-                        $node = (bool)$node;
-                        break;
-                    case self::VAR_INTEGER:
-                        $node = (int)$node;
-                        break;
-                    case self::VAR_BIGINT:
-                        if (\is_string($node) && BigIntValidator::fitsPhpInt($node, $signed)) {
-                            $node = (int)$node;
-                        }
-                        break;
-                    case self::VAR_FLOAT:
-                        $node = (float)$node;
-                        break;
-                    default:
-                        break;
-                }
+                $node = match ($typeKey) {
+                    ColumnType::Id->value => (string) $node,
+                    ColumnType::Boolean->value => (bool) $node,
+                    ColumnType::Integer->value => (int) $node,
+                    ColumnType::BigInteger->value,
+                    ColumnType::BigSerial->value => $this->castBigInteger($node, $signed),
+                    ColumnType::Float->value,
+                    ColumnType::Double->value => (float) $node,
+                    default => $node,
+                };
 
                 $value[$index] = $node;
             }
@@ -9578,142 +1922,97 @@ public function casting(Document $collection, Document $document): Document
         return $document;
     }
 
-    /**
-     * Encode Attribute
-     *
-     * Passes the attribute $value, and $document context to a predefined filter
-     * that allow you to manipulate the input format of the given attribute.
-     *
-     * @param string $name
-     * @param mixed $value
-     * @param Document $document
-     *
-     * @return mixed
-     * @throws DatabaseException
-     */
-    protected function encodeAttribute(string $name, mixed $value, Document $document): mixed
+    private function castBigInteger(mixed $value, bool $signed): mixed
     {
-        if (!array_key_exists($name, self::$filters) && !array_key_exists($name, $this->instanceFilters)) {
-            throw new NotFoundException("Filter: {$name} not found");
-        }
-
-        try {
-            if (\array_key_exists($name, $this->instanceFilters)) {
-                $value = $this->instanceFilters[$name]['encode']($value, $document, $this);
-            } else {
-                $value = self::$filters[$name]['encode']($value, $document, $this);
-            }
-        } catch (\Throwable $th) {
-            throw new DatabaseException($th->getMessage(), $th->getCode(), $th);
+        if (\is_string($value) && BigInt::fitsPhpInt($value, $signed)) {
+            return (int) $value;
         }
 
         return $value;
     }
 
     /**
-     * Decode Attribute
-     *
-     * Passes the attribute $value, and $document context to a predefined filter
-     *  that allow you to manipulate the output format of the given attribute.
-     *
-     * @param string $filter
-     * @param mixed $value
-     * @param Document $document
-     * @param string $attribute
-     * @return mixed
-     * @throws NotFoundException
+     * Set a metadata value to be printed in the query comments
      */
-    protected function decodeAttribute(string $filter, mixed $value, Document $document, string $attribute): mixed
+    public function setMetadata(string $key, mixed $value): static
     {
-        if (!$this->filter) {
-            return $value;
-        }
-
-        if (!\is_null($this->disabledFilters) && isset($this->disabledFilters[$filter])) {
-            return $value;
-        }
-
-        if (!array_key_exists($filter, self::$filters) && !array_key_exists($filter, $this->instanceFilters)) {
-            throw new NotFoundException("Filter \"{$filter}\" not found for attribute \"{$attribute}\"");
-        }
-
-        if (array_key_exists($filter, $this->instanceFilters)) {
-            $value = $this->instanceFilters[$filter]['decode']($value, $document, $this);
-        } else {
-            $value = self::$filters[$filter]['decode']($value, $document, $this);
-        }
+        $this->adapter->setMetadata($key, $value);
 
-        return $value;
+        return $this;
     }
 
     /**
-     * Validate if a set of attributes can be selected from the collection
+     * Get metadata
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @return array<string>
-     * @throws QueryException
+     * @return array<string, mixed>
      */
-    private function validateSelections(Document $collection, array $queries): array
+    public function getMetadata(): array
     {
-        if (empty($queries)) {
-            return [];
-        }
+        return $this->adapter->getMetadata();
+    }
 
-        $selections = [];
-        $relationshipSelections = [];
+    /**
+     * Clear metadata
+     */
+    public function resetMetadata(): void
+    {
+        $this->adapter->resetMetadata();
+    }
 
-        foreach ($queries as $query) {
-            if ($query->getMethod() == Query::TYPE_SELECT) {
-                foreach ($query->getValues() as $value) {
-                    if (!\is_string($value)) {
-                        throw new QueryException('Attribute selection must be a string, got ' . \get_debug_type($value));
-                    }
-                    if (\str_contains($value, '.')) {
-                        $relationshipSelections[] = $value;
-                        continue;
-                    }
-                    $selections[] = $value;
-                }
-            }
+    /**
+     * Executes $callback with $timestamp set to $requestTimestamp
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     */
+    public function withRequestTimestamp(?NativeDateTime $requestTimestamp, callable $callback): mixed
+    {
+        $previous = $this->timestamp;
+        $this->timestamp = $requestTimestamp;
+        try {
+            $result = $callback();
+        } finally {
+            $this->timestamp = $previous;
         }
 
-        // Allow querying internal attributes
-        $keys = \array_map(
-            fn ($attribute) => $attribute['$id'],
-            $this->getInternalAttributes()
-        );
+        return $result;
+    }
 
-        foreach ($collection->getAttribute('attributes', []) as $attribute) {
-            if ($attribute['type'] !== self::VAR_RELATIONSHIP) {
-                // Fallback to $id when key property is not present in metadata table for some tables such as Indexes or Attributes
-                $keys[] = $attribute['key'] ?? $attribute['$id'];
-            }
-        }
-        if ($this->adapter->getSupportForAttributes()) {
-            $invalid = \array_diff($selections, $keys);
-            if (!empty($invalid) && !\in_array('*', $invalid)) {
-                throw new QueryException('Cannot select attributes: ' . \implode(', ', $invalid));
-            }
+    /**
+     * Get getConnection Id
+     *
+     * @throws Exception
+     */
+    public function getConnectionId(): string
+    {
+        if (! $this->adapter->hasFeature(Feature\ConnectionId::class)) {
+            throw new DatabaseException('Adapter does not support connection ids');
         }
 
-        $selections = \array_merge($selections, $relationshipSelections);
+        return $this->adapter->getConnectionId();
+    }
 
-        $selections[] = '$id';
-        $selections[] = '$sequence';
-        $selections[] = '$collection';
-        $selections[] = '$createdAt';
-        $selections[] = '$updatedAt';
-        $selections[] = '$permissions';
+    /**
+     * Ping Database
+     */
+    public function ping(): bool
+    {
+        return $this->adapter->ping();
+    }
 
-        return \array_values(\array_unique($selections));
+    /**
+     * Reconnect to the database, re-establishing any dropped connections.
+     */
+    public function reconnect(): void
+    {
+        $this->adapter->reconnect();
     }
 
     /**
      * Get adapter attribute limit, accounting for internal metadata
      * Returns 0 to indicate no limit
-     *
-     * @return int
      */
     public function getLimitForAttributes(): int
     {
@@ -9726,8 +2025,6 @@ public function getLimitForAttributes(): int
 
     /**
      * Get adapter index limit
-     *
-     * @return int
      */
     public function getLimitForIndexes(): int
     {
@@ -9735,21 +2032,62 @@ public function getLimitForIndexes(): int
     }
 
     /**
-     * @param Document $collection
-     * @param array<Query> $queries
+     * @param  array<Query>  $queries
      * @return array<Query>
+     *
      * @throws QueryException
      * @throws \Utopia\Database\Exception
      */
     public function convertQueries(Document $collection, array $queries): array
+    {
+        $attributesById = $this->buildAttributeMap($collection);
+        $isNestedQueryAttributeSupported = $this->adapter->supports(Capability::DefinedAttributes)
+            && $this->adapter->supports(Capability::Objects);
+
+        return $this->convertQueriesWithMap($queries, $attributesById, $isNestedQueryAttributeSupported);
+    }
+
+    /**
+     * Build an `id => Document` map of the collection's attributes plus
+     * shared internal attribute Documents. Hoisted out so it's computed once
+     * per `convertQueries` call rather than per query / per attribute.
+     *
+     * @return array<string, Document>
+     */
+    private function buildAttributeMap(Document $collection): array
+    {
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        $attributesById = [];
+        foreach ($attributes as $attr) {
+            $attributesById[$attr->getId()] = $attr;
+        }
+        foreach (self::internalAttributeDocuments() as $internal) {
+            $attributesById[$internal->getId()] = $internal;
+        }
+
+        return $attributesById;
+    }
+
+    /**
+     * @param array<Query> $queries
+     * @param array<string, Document> $attributesById
+     * @return array<Query>
+     * @throws QueryException
+     * @throws \Utopia\Database\Exception
+     */
+    private function convertQueriesWithMap(array $queries, array $attributesById, bool $isNestedQueryAttributeSupported): array
     {
         foreach ($queries as $index => $query) {
             if ($query->isNested()) {
-                $values = $this->convertQueries($collection, $query->getValues());
+                /** @var array<Query> $nestedQueries */
+                $nestedQueries = $query->getValues();
+                $values = $this->convertQueriesWithMap($nestedQueries, $attributesById, $isNestedQueryAttributeSupported);
                 $query->setValues($values);
             }
 
-            $query = $this->convertQuery($collection, $query);
+            $query = $this->convertQueryWithMap($query, $attributesById, $isNestedQueryAttributeSupported);
 
             $queries[$index] = $query;
         }
@@ -9758,151 +2096,251 @@ public function convertQueries(Document $collection, array $queries): array
     }
 
     /**
-     * @param Document $collection
-     * @param Query $query
+     * @param  Document  $collection
+     * @param  Query  $query
      * @return Query
+     *
      * @throws QueryException
      * @throws \Utopia\Database\Exception
      */
+    public function convertQuery(Document $collection, Query $query): Query
+    {
+        $attributesById = $this->buildAttributeMap($collection);
+        $isNestedQueryAttributeSupported = $this->adapter->supports(Capability::DefinedAttributes)
+            && $this->adapter->supports(Capability::Objects);
+
+        return $this->convertQueryWithMap($query, $attributesById, $isNestedQueryAttributeSupported);
+    }
+
     /**
-     * Check if values are compatible with object attribute type (hashmap/multi-dimensional array)
-     *
-     * @param array<mixed> $values
-     * @return bool
+     * @param array<string, Document> $attributesById
+     * @return Query
+     * @throws QueryException
+     * @throws \Utopia\Database\Exception
      */
-    private function isCompatibleObjectValue(array $values): bool
+    private function convertQueryWithMap(Query $query, array $attributesById, bool $isNestedQueryAttributeSupported): Query
     {
-        if (empty($values)) {
-            return false;
-        }
+        $queryAttribute = $query->getAttribute();
+        $isNestedQueryAttribute = $isNestedQueryAttributeSupported && \str_contains($queryAttribute, '.');
 
-        foreach ($values as $value) {
-            if (!\is_array($value)) {
-                return false;
-            }
+        $attribute = $attributesById[$queryAttribute] ?? null;
 
-            // Check associative array (hashmap) or nested structure
-            if (empty($value)) {
-                continue;
+        if ($attribute === null && $isNestedQueryAttribute) {
+            $baseAttribute = \explode('.', $queryAttribute, 2)[0];
+            $base = $attributesById[$baseAttribute] ?? null;
+            if ($base !== null && $base->getAttribute('type') === ColumnType::Object->value) {
+                $query->setAttributeType(ColumnType::Object->value);
             }
+        }
 
-            // simple indexed array => not an object
-            if (\array_keys($value) === \range(0, \count($value) - 1)) {
-                return false;
-            }
+        if ($attribute !== null) {
+            /** @var bool $isArray */
+            $isArray = $attribute->getAttribute('array', false);
+            $rawAttrType = $attribute->getAttribute('type');
+            $attrType = $rawAttrType instanceof ColumnType || \is_string($rawAttrType)
+                ? Attribute::normalizeType($rawAttrType)->value
+                : '';
+            $query->setOnArray($isArray);
+            $query->setAttributeType($attrType);
 
-            foreach ($value as $nestedValue) {
-                if (\is_array($nestedValue)) {
-                    continue;
+            if ($attrType == ColumnType::Datetime->value) {
+                $values = $query->getValues();
+                foreach ($values as $valueIndex => $value) {
+                    try {
+                        /** @var string $value */
+                        $values[$valueIndex] = $this->adapter->hasFeature(Feature\UTCCasting::class)
+                            ? $this->adapter->setUTCDatetime($value)
+                            : DateTime::setTimezone($value);
+                    } catch (Throwable $e) {
+                        throw new QueryException($e->getMessage(), $e->getCode(), $e);
+                    }
                 }
+                $query->setValues($values);
+            }
+        } elseif (! $this->adapter->supports(Capability::DefinedAttributes)) {
+            $values = $query->getValues();
+            // setting attribute type to properly apply filters in the adapter level
+            if ($this->adapter->supports(Capability::Objects) && $this->isCompatibleObjectValue($values)) {
+                $query->setAttributeType(ColumnType::Object->value);
             }
         }
 
-        return true;
+        return $query;
     }
 
-    public function convertQuery(Document $collection, Query $query): Query
-    {
-        /**
-         * @var array<Document> $attributes
-         */
-        $attributes = $collection->getAttribute('attributes', []);
+    /**
+     * Parent collection definition used for system and custom collections.
+     *
+     * @return array<string, mixed>
+     */
+    public static function collectionDefinition(): array
+    {
+        /** @var array<string, mixed> $data */
+        $data = (new Collection(
+            id: self::METADATA,
+            name: 'collections',
+            documentSecurity: false,
+            attributes: [
+                Attribute::string(key: 'name', size: 256, required: true),
+                Attribute::string(key: 'attributes', size: 1_000_000, filters: ['json']),
+                Attribute::string(key: 'indexes', size: 1_000_000, filters: ['json']),
+                Attribute::boolean(key: 'documentSecurity', required: true),
+            ],
+        ))->getArrayCopy();
+        $data[Document::COLLECTION] = self::METADATA;
+        $data['attributes'] = self::documentArrays($data['attributes'] ?? []);
+        $data['indexes'] = self::documentArrays($data['indexes'] ?? []);
+
+        return $data;
+    }
 
-        foreach (Database::INTERNAL_ATTRIBUTES as $attribute) {
-            $attributes[] = new Document($attribute);
+    /**
+     * @return array<string, mixed>
+     */
+    protected static function collectionMeta(): array
+    {
+        $collection = self::collectionDefinition();
+        $attributes = [];
+        foreach (self::documentArrays($collection['attributes'] ?? []) as $attribute) {
+            $attributes[] = Attribute::fromArray($attribute);
         }
+        $collection['attributes'] = $attributes;
 
-        $queryAttribute = $query->getAttribute();
-        $isNestedQueryAttribute = $this->getAdapter()->getSupportForAttributes() && $this->getAdapter()->getSupportForObject() && \str_contains($queryAttribute, '.');
+        return $collection;
+    }
+
+    /**
+     * @return list<array<string, mixed>>
+     */
+    private static function documentArrays(mixed $values): array
+    {
+        if (! \is_array($values)) {
+            return [];
+        }
 
-        $attribute = new Document();
+        $arrays = [];
+        foreach ($values as $value) {
+            if ($value instanceof Attribute || $value instanceof Index) {
+                $arrays[] = $value->getArrayCopy();
+                continue;
+            }
+            if ($value instanceof Document) {
+                $arrays[] = $value->getArrayCopy();
+                continue;
+            }
+            if (! \is_array($value)) {
+                continue;
+            }
 
-        foreach ($attributes as $attr) {
-            if ($attr->getId() === $query->getAttribute()) {
-                $attribute = $attr;
-            } elseif ($isNestedQueryAttribute) {
-                // nested object query
-                $baseAttribute = \explode('.', $queryAttribute, 2)[0];
-                if ($baseAttribute === $attr->getId() && $attr->getAttribute('type') === Database::VAR_OBJECT) {
-                    $query->setAttributeType(Database::VAR_OBJECT);
+            $typed = [];
+            foreach ($value as $key => $item) {
+                if (\is_string($key)) {
+                    $typed[$key] = $item;
                 }
             }
+            $arrays[] = $typed;
         }
 
-        if (!$attribute->isEmpty()) {
-            $query->setOnArray($attribute->getAttribute('array', false));
-            $query->setAttributeType($attribute->getAttribute('type'));
+        return $arrays;
+    }
 
-            if ($attribute->getAttribute('type') == Database::VAR_DATETIME) {
-                $values = $query->getValues();
-                foreach ($values as $valueIndex => $value) {
-                    try {
-                        $values[$valueIndex] = $this->adapter->getSupportForUTCCasting()
-                            ? $this->adapter->setUTCDatetime($value)
-                            : DateTime::setTimezone($value);
-                    } catch (\Throwable $e) {
-                        throw new QueryException($e->getMessage(), $e->getCode(), $e);
-                    }
-                }
-                $query->setValues($values);
-            }
-        } elseif (!$this->adapter->getSupportForAttributes()) {
-            $values = $query->getValues();
-            // setting attribute type to properly apply filters in the adapter level
-            if ($this->adapter->getSupportForObject() && $this->isCompatibleObjectValue($values)) {
-                $query->setAttributeType(Database::VAR_OBJECT);
+    /**
+     * Get the list of internal attribute definitions (e.g., $id, $createdAt, $permissions) as typed Attribute objects.
+     *
+     * @return array<Attribute>
+     */
+    public static function internalAttributes(): array
+    {
+        if (self::$internalAttributes === null) {
+            self::$internalAttributes = \array_map(
+                fn (array $attr): Attribute => Attribute::fromArray($attr),
+                self::INTERNAL_ATTRIBUTES
+            );
+        }
+
+        return self::$internalAttributes;
+    }
+
+    /**
+     * Get the internal attribute definitions as Document instances. Reuses a
+     * process-lifetime cache to avoid re-allocating these on every read.
+     *
+     * Returned Documents MUST NOT be mutated by callers — they are shared singletons.
+     *
+     * @return array<Document>
+     */
+    private static function internalAttributeDocuments(): array
+    {
+        if (self::$internalAttributeDocuments === null) {
+            self::$internalAttributeDocuments = [];
+            foreach (Database::INTERNAL_ATTRIBUTES as $attribute) {
+                self::$internalAttributeDocuments[] = new Document($attribute);
             }
         }
 
-        return $query;
+        return self::$internalAttributeDocuments;
     }
 
     /**
-     * @return  array<array<string, mixed>>
+     * Get the internal attribute definitions for the current adapter, excluding tenant if shared tables are disabled.
+     *
+     * @return array<array<string, mixed>> The internal attribute configurations.
      */
     public function getInternalAttributes(): array
     {
-        $attributes = self::INTERNAL_ATTRIBUTES;
-
-        if (!$this->adapter->getSharedTables()) {
-            $attributes = \array_filter(Database::INTERNAL_ATTRIBUTES, function ($attribute) {
-                return $attribute['$id'] !== '$tenant';
-            });
+        if (self::$internalAttributeArrays === null) {
+            $withTenant = self::INTERNAL_ATTRIBUTES;
+            $withoutTenant = \array_values(\array_filter(
+                self::INTERNAL_ATTRIBUTES,
+                static fn (array $attribute): bool => $attribute[Document::ID] !== Document::TENANT,
+            ));
+            self::$internalAttributeArrays = [
+                0 => $withoutTenant,
+                1 => $withTenant,
+            ];
         }
 
-        return $attributes;
+        return self::$internalAttributeArrays[$this->adapter->getSharedTables() ? 1 : 0];
     }
 
     /**
      * Get Schema Attributes
      *
-     * @param string $collection
      * @return array<Document>
+     *
      * @throws DatabaseException
      */
     public function getSchemaAttributes(string $collection): array
     {
+        if (! $this->adapter->hasFeature(Feature\SchemaAttributes::class)) {
+            return [];
+        }
+
         return $this->adapter->getSchemaAttributes($collection);
     }
 
     /**
-     * @param string $collection
+     * Get the physical schema indexes for a collection from the database engine.
+     *
+     * @param string $collection The collection identifier.
      * @return array<Document>
      */
     public function getSchemaIndexes(string $collection): array
     {
+        if (! $this->adapter->hasFeature(Feature\SchemaIndexes::class)) {
+            return [];
+        }
+
         return $this->adapter->getSchemaIndexes($collection);
     }
 
     /**
-     * @param string $collectionId
-     * @param string|null $documentId
-     * @param array<string> $selects
+     * @param  array<string>  $selects
      * @return array{0: string, 1: string, 2: string}
      */
     public function getCacheKeys(string $collectionId, ?string $documentId = null, array $selects = []): array
     {
-        if ($this->adapter->getSupportForHostname()) {
+        if ($this->adapter->supports(Capability::Hostname)) {
             $hostname = $this->adapter->getHostname();
         }
 
@@ -9911,6 +2349,7 @@ public function getCacheKeys(string $collectionId, ?string $documentId = null, a
         if (
             $collectionId === self::METADATA &&
             $this->adapter->getSharedTables() &&
+            $documentId !== null &&
             isset($this->globalCollections[$documentId])
         ) {
             $tenantSegment = null;
@@ -9931,10 +2370,34 @@ public function getCacheKeys(string $collectionId, ?string $documentId = null, a
             $sortedSelects = $selects;
             \sort($sortedSelects);
 
+            $filterSignatures = [];
+            if ($this->filter) {
+                $disabled = $this->disabledFilters ?? [];
+
+                foreach (self::$filters as $name => $callbacks) {
+                    if (isset($disabled[$name])) {
+                        continue;
+                    }
+                    if (\array_key_exists($name, $this->instanceFilters)) {
+                        continue;
+                    }
+                    $filterSignatures[$name] = $callbacks['signature'];
+                }
+
+                foreach ($this->instanceFilters as $name => $callbacks) {
+                    if (isset($disabled[$name])) {
+                        continue;
+                    }
+                    $filterSignatures[$name] = $callbacks['signature'];
+                }
+
+                \ksort($filterSignatures);
+            }
+
             $payload = \json_encode([
                 'selects' => $sortedSelects,
-                'relationships' => $this->resolveRelationships,
-                'filters' => $this->getActiveFilterSignatures(),
+                'relationships' => $this->relationshipHook?->isEnabled() ?? false,
+                'filters' => $filterSignatures,
             ]) ?: '';
             $documentHashKey = $documentKey . ':' . \md5($payload);
         }
@@ -9942,20 +2405,16 @@ public function getCacheKeys(string $collectionId, ?string $documentId = null, a
         return [
             $collectionKey,
             $documentKey ?? '',
-            $documentHashKey ?? ''
+            $documentHashKey ?? '',
         ];
     }
 
     /**
      * Stable cache key for cached query entries on a collection.
-     *
-     * @param string $collectionId
-     * @param string|null $namespace
-     * @return string
      */
     public function getQueryCacheKey(string $collectionId, ?string $namespace = null): string
     {
-        $hostname = $this->adapter->getSupportForHostname()
+        $hostname = $this->adapter->supports(Capability::Hostname)
             ? $this->adapter->getHostname()
             : '';
 
@@ -9972,24 +2431,26 @@ public function getQueryCacheKey(string $collectionId, ?string $namespace = null
     /**
      * Stable cache field for cached query entries on a collection.
      *
-     * @param Document|null $collection
-     * @param array<Query> $queries
-     * @param string $field
-     * @param string $forPermission
-     * @return string|null
+     * @param  array<Query>  $queries
      */
     public function getQueryCacheField(
         ?Document $collection = null,
         array $queries = [],
         string $field = 'documents',
-        string $forPermission = self::PERMISSION_READ,
+        PermissionType $forPermission = PermissionType::Read,
     ): ?string {
         $this->checkQueryTypes($queries);
 
-        if ($forPermission !== self::PERMISSION_READ) {
+        if ($forPermission !== PermissionType::Read || $this->adapter->inTransaction()) {
             return null;
         }
 
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::OrderRandom) {
+                return null;
+            }
+        }
+
         $authorizationRoles = \array_values(\array_unique($this->authorization->getRoles()));
         \sort($authorizationRoles);
 
@@ -10003,766 +2464,284 @@ public function getQueryCacheField(
             'queries' => \array_map(
                 fn (Query $query): array => $this->serializeQueryCacheQuery($query),
                 $queries,
-            ),
-            'relationships' => $this->resolveRelationships,
-            'filters' => $this->getActiveFilterSignatures(),
-        ];
-
-        $schemaHash = '';
-        if ($collection !== null && !$collection->isEmpty()) {
-            // Schema-affecting changes must move callers onto a fresh cache field.
-            $schemaHash = \md5(
-                \json_encode($collection->getAttribute('attributes', []))
-                . \json_encode($collection->getAttribute('indexes', []))
-                . \json_encode($collection->getAttribute('$permissions', []))
-                . \json_encode($collection->getAttribute('documentSecurity', false))
-            );
-        }
-
-        return \sprintf(
-            '%s:%s:%s',
-            $schemaHash,
-            \md5(\json_encode($queryPayload) ?: ''),
-            $field,
-        );
-    }
-
-    /**
-     * @return array<string, mixed>
-     */
-    private function serializeQueryCacheQuery(Query $query): array
-    {
-        $serialized = [
-            'method' => $query->getMethod(),
-        ];
-
-        if ($query->getAttribute() !== '') {
-            $serialized['attribute'] = $query->getAttribute();
-        }
-
-        $values = [];
-        foreach ($query->getValues() as $value) {
-            if ($value instanceof Query) {
-                $values[] = $this->serializeQueryCacheQuery($value);
-                continue;
-            }
-
-            $values[] = $this->normalizeQueryCacheQueryValue($value);
-        }
-
-        $serialized['values'] = $values;
-
-        return $serialized;
-    }
-
-    private function normalizeQueryCacheQueryValue(mixed $value): mixed
-    {
-        if ($value instanceof Document) {
-            $value = $value->getArrayCopy();
-        }
-
-        if (!\is_array($value)) {
-            return $value;
-        }
-
-        foreach ($value as $key => $item) {
-            $value[$key] = $this->normalizeQueryCacheQueryValue($item);
-        }
-
-        return $value;
-    }
-
-    /**
-     * @return array<string, string>
-     */
-    private function getActiveFilterSignatures(): array
-    {
-        $filterSignatures = [];
-        if (!$this->filter) {
-            return $filterSignatures;
-        }
-
-        $disabled = $this->disabledFilters ?? [];
-
-        foreach (self::$filters as $name => $callbacks) {
-            if (isset($disabled[$name])) {
-                continue;
-            }
-            if (\array_key_exists($name, $this->instanceFilters)) {
-                continue;
-            }
-            $filterSignatures[$name] = $callbacks['signature'];
-        }
-
-        foreach ($this->instanceFilters as $name => $callbacks) {
-            if (isset($disabled[$name])) {
-                continue;
-            }
-            $filterSignatures[$name] = $callbacks['signature'];
-        }
-
-        \ksort($filterSignatures);
-
-        return $filterSignatures;
-    }
-
-    private static function computeCallableSignature(callable $callable): string
-    {
-        if (\is_string($callable)) {
-            return $callable;
-        }
-
-        if (\is_array($callable)) {
-            $class = \is_object($callable[0]) ? \get_class($callable[0]) : $callable[0];
-            return $class . '::' . $callable[1];
-        }
-
-        $closure = \Closure::fromCallable($callable);
-        $ref = new \ReflectionFunction($closure);
-        return ($ref->getFileName() ?: 'unknown') . ':' . $ref->getStartLine();
-    }
-
-    /**
-     * @param array<Query> $queries
-     * @return void
-     * @throws QueryException
-     */
-    private function checkQueryTypes(array $queries): void
-    {
-        foreach ($queries as $query) {
-            if (!$query instanceof Query) {
-                throw new QueryException('Invalid query type: "' . \gettype($query) . '". Expected instances of "' . Query::class . '"');
-            }
-
-            if ($query->isNested()) {
-                $this->checkQueryTypes($query->getValues());
-            }
-        }
-    }
-
-    /**
-     * Process relationship queries, extracting nested selections.
-     *
-     * @param array<Document> $relationships
-     * @param array<Query> $queries
-     * @return array<string, array<Query>> $selects
-     */
-    private function processRelationshipQueries(
-        array $relationships,
-        array $queries,
-    ): array {
-        $nestedSelections = [];
-
-        foreach ($queries as $query) {
-            if ($query->getMethod() !== Query::TYPE_SELECT) {
-                continue;
-            }
-
-            $values = $query->getValues();
-            foreach ($values as $valueIndex => $value) {
-                if (!\is_string($value) || !\str_contains($value, '.')) {
-                    continue;
-                }
-
-                $nesting = \explode('.', $value);
-                $selectedKey = \array_shift($nesting); // Remove and return first item
-
-                $relationship = \array_values(\array_filter(
-                    $relationships,
-                    fn (Document $relationship) => $relationship->getAttribute('key') === $selectedKey,
-                ))[0] ?? null;
-
-                if (!$relationship) {
-                    continue;
-                }
-
-                // Shift the top level off the dot-path to pass the selection down the chain
-                // 'foo.bar.baz' becomes 'bar.baz'
-
-                $nestingPath = \implode('.', $nesting);
-
-                // If nestingPath is empty, it means we want all attributes (*) for this relationship
-                if (empty($nestingPath)) {
-                    $nestedSelections[$selectedKey][] = Query::select(['*']);
-                } else {
-                    $nestedSelections[$selectedKey][] = Query::select([$nestingPath]);
-                }
-
-                $type = $relationship->getAttribute('options')['relationType'];
-                $side = $relationship->getAttribute('options')['side'];
-
-                switch ($type) {
-                    case Database::RELATION_MANY_TO_MANY:
-                        unset($values[$valueIndex]);
-                        break;
-                    case Database::RELATION_ONE_TO_MANY:
-                        if ($side === Database::RELATION_SIDE_PARENT) {
-                            unset($values[$valueIndex]);
-                        } else {
-                            $values[$valueIndex] = $selectedKey;
-                        }
-                        break;
-                    case Database::RELATION_MANY_TO_ONE:
-                        if ($side === Database::RELATION_SIDE_PARENT) {
-                            $values[$valueIndex] = $selectedKey;
-                        } else {
-                            unset($values[$valueIndex]);
-                        }
-                        break;
-                    case Database::RELATION_ONE_TO_ONE:
-                        $values[$valueIndex] = $selectedKey;
-                        break;
-                }
-            }
-
-            $finalValues = \array_values($values);
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                if (empty($finalValues)) {
-                    $finalValues = ['*'];
-                }
-            }
-            $query->setValues($finalValues);
-        }
-
-        return $nestedSelections;
-    }
-
-    /**
-     * Process nested relationship path iteratively
-     *
-     * Instead of recursive calls, this method processes multi-level queries in a single loop
-     * working from the deepest level up to minimize database queries.
-     *
-     * Example: For "project.employee.company.name":
-     * 1. Query companies matching name filter -> IDs [c1, c2]
-     * 2. Query employees with company IN [c1, c2] -> IDs [e1, e2, e3]
-     * 3. Query projects with employee IN [e1, e2, e3] -> IDs [p1, p2]
-     * 4. Return [p1, p2]
-     *
-     * @param string $startCollection The starting collection for the path
-     * @param array<Query> $queries Queries with nested paths
-     * @return array<string>|null Array of matching IDs or null if no matches
-     */
-    private function processNestedRelationshipPath(string $startCollection, array $queries): ?array
-    {
-        // Build a map of all nested paths and their queries
-        $pathGroups = [];
-        foreach ($queries as $query) {
-            $attribute = $query->getAttribute();
-            if (\str_contains($attribute, '.')) {
-                $parts = \explode('.', $attribute);
-                $pathKey = \implode('.', \array_slice($parts, 0, -1)); // Everything except the last part
-                if (!isset($pathGroups[$pathKey])) {
-                    $pathGroups[$pathKey] = [];
-                }
-                $pathGroups[$pathKey][] = [
-                    'method' => $query->getMethod(),
-                    'attribute' => \end($parts), // The actual attribute to query
-                    'values' => $query->getValues(),
-                ];
-            }
-        }
-
-        $allMatchingIds = [];
-        foreach ($pathGroups as $path => $queryGroup) {
-            $pathParts = \explode('.', $path);
-            $currentCollection = $startCollection;
-            $relationshipChain = [];
-
-            foreach ($pathParts as $relationshipKey) {
-                $collectionDoc = $this->silent(fn () => $this->getCollection($currentCollection));
-                $relationships = \array_filter(
-                    $collectionDoc->getAttribute('attributes', []),
-                    fn ($attr) => $attr['type'] === self::VAR_RELATIONSHIP
-                );
-
-                $relationship = null;
-                foreach ($relationships as $rel) {
-                    if ($rel['key'] === $relationshipKey) {
-                        $relationship = $rel;
-                        break;
-                    }
-                }
-
-                if (!$relationship) {
-                    return null;
-                }
-
-                $relationshipChain[] = [
-                    'key' => $relationshipKey,
-                    'fromCollection' => $currentCollection,
-                    'toCollection' => $relationship['options']['relatedCollection'],
-                    'relationType' => $relationship['options']['relationType'],
-                    'side' => $relationship['options']['side'],
-                    'twoWayKey' => $relationship['options']['twoWayKey'],
-                ];
-
-                $currentCollection = $relationship['options']['relatedCollection'];
-            }
-
-            // Now walk backwards from the deepest collection to the starting collection
-            $leafQueries = [];
-            foreach ($queryGroup as $q) {
-                $leafQueries[] = new Query($q['method'], $q['attribute'], $q['values']);
-            }
-
-            // Query the deepest collection
-            $matchingDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find(
-                $currentCollection,
-                \array_merge($leafQueries, [
-                    Query::select(['$id']),
-                    Query::limit(PHP_INT_MAX),
-                ])
-            )));
-
-            $matchingIds = \array_map(fn ($doc) => $doc->getId(), $matchingDocs);
-
-            if (empty($matchingIds)) {
-                return null;
-            }
-
-            // Walk back up the chain
-            for ($i = \count($relationshipChain) - 1; $i >= 0; $i--) {
-                $link = $relationshipChain[$i];
-                $relationType = $link['relationType'];
-                $side = $link['side'];
-
-                // Determine how to query the parent collection
-                $needsReverseLookup = (
-                    ($relationType === self::RELATION_ONE_TO_MANY && $side === self::RELATION_SIDE_PARENT) ||
-                    ($relationType === self::RELATION_MANY_TO_ONE && $side === self::RELATION_SIDE_CHILD) ||
-                    ($relationType === self::RELATION_MANY_TO_MANY)
-                );
-
-                if ($needsReverseLookup) {
-                    if ($relationType === self::RELATION_MANY_TO_MANY) {
-                        // For many-to-many, query the junction table directly instead
-                        // of resolving full relationships on the child documents.
-                        $fromCollectionDoc = $this->silent(fn () => $this->getCollection($link['fromCollection']));
-                        $toCollectionDoc = $this->silent(fn () => $this->getCollection($link['toCollection']));
-                        $junction = $this->getJunctionCollection($fromCollectionDoc, $toCollectionDoc, $link['side']);
-
-                        $junctionDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find($junction, [
-                            Query::equal($link['key'], $matchingIds),
-                            Query::limit(PHP_INT_MAX),
-                        ])));
-
-                        $parentIds = [];
-                        foreach ($junctionDocs as $jDoc) {
-                            $pId = $jDoc->getAttribute($link['twoWayKey']);
-                            if ($pId && !\in_array($pId, $parentIds)) {
-                                $parentIds[] = $pId;
-                            }
-                        }
-                    } else {
-                        // Need to find parents by querying children and extracting parent IDs
-                        $childDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find(
-                            $link['toCollection'],
-                            [
-                                Query::equal('$id', $matchingIds),
-                                Query::select(['$id', $link['twoWayKey']]),
-                                Query::limit(PHP_INT_MAX),
-                            ]
-                        )));
-
-                        $parentIds = [];
-                        foreach ($childDocs as $doc) {
-                            $parentValue = $doc->getAttribute($link['twoWayKey']);
-                            if (\is_array($parentValue)) {
-                                foreach ($parentValue as $pId) {
-                                    if ($pId instanceof Document) {
-                                        $pId = $pId->getId();
-                                    }
-                                    if ($pId && !\in_array($pId, $parentIds)) {
-                                        $parentIds[] = $pId;
-                                    }
-                                }
-                            } else {
-                                if ($parentValue instanceof Document) {
-                                    $parentValue = $parentValue->getId();
-                                }
-                                if ($parentValue && !\in_array($parentValue, $parentIds)) {
-                                    $parentIds[] = $parentValue;
-                                }
-                            }
-                        }
-                    }
-                    $matchingIds = $parentIds;
-                } else {
-                    // Can directly filter parent by the relationship key
-                    $parentDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find(
-                        $link['fromCollection'],
-                        [
-                            Query::equal($link['key'], $matchingIds),
-                            Query::select(['$id']),
-                            Query::limit(PHP_INT_MAX),
-                        ]
-                    )));
-                    $matchingIds = \array_map(fn ($doc) => $doc->getId(), $parentDocs);
-                }
-
-                if (empty($matchingIds)) {
-                    return null;
-                }
-            }
+            ),
+            'relationships' => $this->relationshipHook?->isEnabled() ?? false,
+            'filters' => $this->getActiveFilterSignatures(),
+        ];
 
-            $allMatchingIds = \array_merge($allMatchingIds, $matchingIds);
+        $schemaHash = '';
+        if ($collection !== null && ! $collection->isEmpty()) {
+            $schemaHash = \md5(
+                (\json_encode($collection->getAttribute('attributes', [])) ?: '')
+                .(\json_encode($collection->getAttribute('indexes', [])) ?: '')
+                .(\json_encode($collection->getAttribute(Document::PERMISSIONS, [])) ?: '')
+                .(\json_encode($collection->getAttribute('documentSecurity', false)) ?: '')
+            );
         }
 
-        return \array_unique($allMatchingIds);
+        return \sprintf(
+            '%s:%s:%s',
+            $schemaHash,
+            \md5(\json_encode($queryPayload) ?: ''),
+            $field,
+        );
     }
 
     /**
-     * Convert relationship queries to SQL-safe subqueries recursively
-     *
-     * Queries like Query::equal('author.name', ['Alice']) are converted to
-     * Query::equal('author', [<matching author IDs>])
-     *
-     * This method supports multi-level nested relationship queries:
-     * - Depth 1: employee.name
-     * - Depth 2: employee.company.name
-     * - Depth 3: project.employee.company.name
-     *
-     * The method works by:
-     * 1. Parsing dot-path queries (e.g., "project.employee.company.name")
-     * 2. Extracting the first relationship (e.g., "project")
-     * 3. If the nested attribute still contains dots, using iterative processing
-     * 4. Finding matching documents in the related collection
-     * 5. Converting to filters on the parent collection
-     *
-     * @param array<Document> $relationships
-     * @param array<Query> $queries
-     * @return array<Query>|null Returns null if relationship filters cannot match any documents
+     * @return array<string, mixed>
      */
-    private function convertRelationshipQueries(
-        array $relationships,
-        array $queries,
-        ?Document $collection = null,
-    ): ?array {
-        // Early return if no relationship queries exist
-        $hasRelationshipQuery = false;
-        foreach ($queries as $query) {
-            $attr = $query->getAttribute();
-            if (\str_contains($attr, '.') || $query->getMethod() === Query::TYPE_CONTAINS_ALL) {
-                $hasRelationshipQuery = true;
-                break;
-            }
-        }
-
-        if (!$hasRelationshipQuery) {
-            return $queries;
-        }
+    private function serializeQueryCacheQuery(Query $query): array
+    {
+        $serialized = [
+            'method' => $query->getMethod()->value,
+        ];
 
-        $relationshipsByKey = [];
-        foreach ($relationships as $relationship) {
-            $relationshipsByKey[$relationship->getAttribute('key')] = $relationship;
+        if ($query->getAttribute() !== '') {
+            $serialized['attribute'] = $query->getAttribute();
         }
 
-        $additionalQueries = [];
-        $groupedQueries = [];
-        $indicesToRemove = [];
-
-        // Handle containsAll queries first
-        foreach ($queries as $index => $query) {
-            if ($query->getMethod() !== Query::TYPE_CONTAINS_ALL) {
+        $values = [];
+        foreach ($query->getValues() as $value) {
+            if ($value instanceof Query) {
+                $values[] = $this->serializeQueryCacheQuery($value);
                 continue;
             }
 
-            $attribute = $query->getAttribute();
+            $values[] = $this->normalizeQueryCacheQueryValue($value);
+        }
 
-            if (!\str_contains($attribute, '.')) {
-                continue; // Non-relationship containsAll handled by adapter
-            }
+        $serialized['values'] = $values;
 
-            $parts = \explode('.', $attribute);
-            $relationshipKey = \array_shift($parts);
-            $nestedAttribute = \implode('.', $parts);
-            $relationship = $relationshipsByKey[$relationshipKey] ?? null;
+        return $serialized;
+    }
 
-            if (!$relationship) {
-                continue;
-            }
+    private function normalizeQueryCacheQueryValue(mixed $value): mixed
+    {
+        if ($value instanceof Document) {
+            $value = $value->getArrayCopy();
+        }
 
-            // Resolve each value independently, then intersect parent IDs
-            $parentIdSets = [];
-            $resolvedAttribute = '$id';
-            foreach ($query->getValues() as $value) {
-                $relatedQuery = Query::equal($nestedAttribute, [$value]);
-                $result = $this->resolveRelationshipGroupToIds($relationship, [$relatedQuery], $collection);
+        if (! \is_array($value)) {
+            return $value;
+        }
 
-                if ($result === null) {
-                    return null;
-                }
+        foreach ($value as $key => $item) {
+            $value[$key] = $this->normalizeQueryCacheQueryValue($item);
+        }
 
-                $resolvedAttribute = $result['attribute'];
-                $parentIdSets[] = $result['ids'];
-            }
+        return $value;
+    }
 
-            $ids = \count($parentIdSets) > 1
-                ? \array_values(\array_intersect(...$parentIdSets))
-                : ($parentIdSets[0] ?? []);
+    protected function getCollectionMetadataCacheKey(string $collection): string
+    {
+        $tenant = $this->adapter->getTenant();
+        $tenantKey = match (true) {
+            $tenant === null => 'null',
+            \is_int($tenant) => 'integer:'.$tenant,
+            default => 'string:'.\strlen($tenant).':'.$tenant,
+        };
 
-            if (empty($ids)) {
-                return null;
-            }
+        return $this->adapter->getDatabase().'::'.$this->adapter->getNamespace()
+            .'::'.$tenantKey.'::'.$collection;
+    }
 
-            $additionalQueries[] = Query::equal($resolvedAttribute, $ids);
-            $indicesToRemove[] = $index;
+    /**
+     * @return array<string, string>
+     */
+    private function getActiveFilterSignatures(): array
+    {
+        $filterSignatures = [];
+        if (! $this->filter) {
+            return $filterSignatures;
         }
 
-        // Group regular dot-path queries by relationship key
-        foreach ($queries as $index => $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT || $query->getMethod() === Query::TYPE_CONTAINS_ALL) {
-                continue;
-            }
-
-            $attribute = $query->getAttribute();
+        $disabled = $this->disabledFilters ?? [];
 
-            if (!\str_contains($attribute, '.')) {
+        foreach (self::$filters as $name => $callbacks) {
+            if (isset($disabled[$name]) || \array_key_exists($name, $this->instanceFilters)) {
                 continue;
             }
+            $filterSignatures[$name] = $callbacks['signature'];
+        }
 
-            $parts = \explode('.', $attribute);
-            $relationshipKey = \array_shift($parts);
-            $nestedAttribute = \implode('.', $parts);
-            $relationship = $relationshipsByKey[$relationshipKey] ?? null;
-
-            if (!$relationship) {
+        foreach ($this->instanceFilters as $name => $callbacks) {
+            if (isset($disabled[$name])) {
                 continue;
             }
+            $filterSignatures[$name] = $callbacks['signature'];
+        }
 
-            if (!isset($groupedQueries[$relationshipKey])) {
-                $groupedQueries[$relationshipKey] = [
-                    'relationship' => $relationship,
-                    'queries' => [],
-                    'indices' => []
-                ];
-            }
+        \ksort($filterSignatures);
 
-            $groupedQueries[$relationshipKey]['queries'][] = [
-                'method' => $query->getMethod(),
-                'attribute' => $nestedAttribute,
-                'values' => $query->getValues()
-            ];
+        return $filterSignatures;
+    }
 
-            $groupedQueries[$relationshipKey]['indices'][] = $index;
-        }
+    /**
+     * Fire an event to mandatory cache invalidation and registered lifecycle hooks.
+     * Mandatory invalidation is never silenced and failures are propagated.
+     */
+    protected function trigger(Event $event, mixed $data = null): void
+    {
+        $this->invalidate($event, $data);
+        $this->triggerHooks($event, $data);
+    }
 
-        // Process each relationship group
-        foreach ($groupedQueries as $relationshipKey => $group) {
-            $relationship = $group['relationship'];
-
-            // Detect impossible conditions: multiple equal on same attribute
-            $equalAttrs = [];
-            foreach ($group['queries'] as $queryData) {
-                if ($queryData['method'] === Query::TYPE_EQUAL) {
-                    $attr = $queryData['attribute'];
-                    if (isset($equalAttrs[$attr])) {
-                        throw new QueryException("Multiple equal queries on '{$relationshipKey}.{$attr}' will never match a single document. Use Query::containsAll() to match across different related documents.");
-                    }
-                    $equalAttrs[$attr] = true;
-                }
-            }
+    /**
+     * Run mandatory cache invalidation for a lifecycle event.
+     */
+    protected function invalidate(Event $event, mixed $data = null): void
+    {
+        $this->queryCacheInvalidator?->handle($event, $data);
+    }
 
-            $relatedQueries = [];
-            foreach ($group['queries'] as $queryData) {
-                $relatedQueries[] = new Query(
-                    $queryData['method'],
-                    $queryData['attribute'],
-                    $queryData['values']
-                );
-            }
+    /**
+     * @return array<string, string>
+     */
+    protected function getInvalidationTokens(Event $event, mixed $data = null): array
+    {
+        return $this->queryCacheInvalidator?->tokens($event, $data) ?? [];
+    }
 
-            try {
-                $result = $this->resolveRelationshipGroupToIds($relationship, $relatedQueries, $collection);
+    /**
+     * @param  array<string, string>  $tokens
+     */
+    protected function blockInvalidation(array $tokens): void
+    {
+        $this->queryCacheInvalidator?->block($tokens);
+    }
 
-                if ($result === null) {
-                    return null;
-                }
+    /**
+     * @param  array<string, string>  $tokens
+     */
+    protected function activateInvalidation(array $tokens): void
+    {
+        $this->queryCacheInvalidator?->activate($tokens);
+    }
 
-                $additionalQueries[] = Query::equal($result['attribute'], $result['ids']);
+    /**
+     * Fire suppressible user lifecycle hooks after mandatory invalidation succeeds.
+     */
+    protected function triggerHooks(Event $event, mixed $data = null): void
+    {
 
-                foreach ($group['indices'] as $originalIndex) {
-                    $indicesToRemove[] = $originalIndex;
-                }
-            } catch (QueryException $e) {
-                throw $e;
-            } catch (\Exception $e) {
-                return null;
-            }
+        if ($this->areEventsSilenced()) {
+            return;
         }
 
-        // Remove the original queries
-        foreach ($indicesToRemove as $index) {
-            unset($queries[$index]);
+        foreach ($this->lifecycleHooks as $hook) {
+            try {
+                $hook->handle($event, $data);
+            } catch (Throwable) {
+                // Lifecycle hooks must not break business logic
+            }
         }
-
-        // Merge additional queries
-        return \array_merge(\array_values($queries), $additionalQueries);
     }
 
     /**
-     * Resolve a group of relationship queries to matching document IDs.
+     * Create a document instance of the appropriate type
      *
-     * @param Document $relationship
-     * @param array<Query> $relatedQueries Queries on the related collection
-     * @param Document|null $collection The parent collection document (needed for junction table lookups)
-     * @return array{attribute: string, ids: string[]}|null
+     * @param  string  $collection  Collection ID
+     * @param  array<string, mixed>  $data  Document data
      */
-    private function resolveRelationshipGroupToIds(
-        Document $relationship,
-        array $relatedQueries,
-        ?Document $collection = null,
-    ): ?array {
-        $relatedCollection = $relationship->getAttribute('options')['relatedCollection'];
-        $relationType = $relationship->getAttribute('options')['relationType'];
-        $side = $relationship->getAttribute('options')['side'];
-        $relationshipKey = $relationship->getAttribute('key');
-
-        // Process multi-level queries by walking the relationship chain
-        $hasNestedPaths = false;
-        foreach ($relatedQueries as $relatedQuery) {
-            if (\str_contains($relatedQuery->getAttribute(), '.')) {
-                $hasNestedPaths = true;
-                break;
-            }
+    protected function createDocumentInstance(string $collection, array $data): Document
+    {
+        if ($data === []) {
+            return new Document();
         }
 
-        if ($hasNestedPaths) {
-            $matchingIds = $this->processNestedRelationshipPath(
-                $relatedCollection,
-                $relatedQueries
-            );
+        $className = $this->documentTypes[$collection] ?? Document::class;
 
-            if ($matchingIds === null || empty($matchingIds)) {
-                return null;
-            }
+        return $className::fromArray($data);
+    }
 
-            $relatedQueries = \array_values(\array_merge(
-                \array_filter($relatedQueries, fn (Query $q) => !\str_contains($q->getAttribute(), '.')),
-                [Query::equal('$id', $matchingIds)]
-            ));
+    /**
+     * Encode Attribute
+     *
+     * Passes the attribute $value, and $document context to a predefined filter
+     * that allow you to manipulate the input format of the given attribute.
+     *
+     *
+     * @throws DatabaseException
+     */
+    protected function encodeAttribute(string $name, mixed $value, Document $document): mixed
+    {
+        if (! array_key_exists($name, self::$filters) && ! array_key_exists($name, $this->instanceFilters)) {
+            throw new NotFoundException("Filter: {$name} not found");
         }
 
-        $needsParentResolution = (
-            ($relationType === self::RELATION_ONE_TO_MANY && $side === self::RELATION_SIDE_PARENT) ||
-            ($relationType === self::RELATION_MANY_TO_ONE && $side === self::RELATION_SIDE_CHILD) ||
-            ($relationType === self::RELATION_MANY_TO_MANY)
-        );
-
-        if ($relationType === self::RELATION_MANY_TO_MANY && $needsParentResolution && $collection !== null) {
-            // For many-to-many, query the junction table directly instead of relying
-            // on relationship population (which fails when resolveRelationships is false,
-            // e.g. when the outer find() is wrapped in skipRelationships()).
-            $matchingDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find(
-                $relatedCollection,
-                \array_merge($relatedQueries, [
-                    Query::select(['$id']),
-                    Query::limit(PHP_INT_MAX),
-                ])
-            )));
-
-            $matchingIds = \array_map(fn ($doc) => $doc->getId(), $matchingDocs);
-
-            if (empty($matchingIds)) {
-                return null;
-            }
-
-            $twoWayKey = $relationship->getAttribute('options')['twoWayKey'];
-            $relatedCollectionDoc = $this->silent(fn () => $this->getCollection($relatedCollection));
-            $junction = $this->getJunctionCollection($collection, $relatedCollectionDoc, $side);
-
-            $junctionDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find($junction, [
-                Query::equal($relationshipKey, $matchingIds),
-                Query::limit(PHP_INT_MAX),
-            ])));
-
-            $parentIds = [];
-            foreach ($junctionDocs as $jDoc) {
-                $pId = $jDoc->getAttribute($twoWayKey);
-                if ($pId && !\in_array($pId, $parentIds)) {
-                    $parentIds[] = $pId;
-                }
+        try {
+            if (\array_key_exists($name, $this->instanceFilters)) {
+                $value = $this->instanceFilters[$name]['encode']($value, $document, $this);
+            } else {
+                $value = self::$filters[$name]['encode']($value, $document, $this);
             }
+        } catch (Throwable $th) {
+            throw new DatabaseException($th->getMessage(), $th->getCode(), $th);
+        }
 
-            return empty($parentIds) ? null : ['attribute' => '$id', 'ids' => $parentIds];
-        } elseif ($needsParentResolution) {
-            // For one-to-many/many-to-one parent resolution, we need relationship
-            // population to read the twoWayKey attribute from the related documents.
-            $matchingDocs = $this->silent(fn () => $this->find(
-                $relatedCollection,
-                \array_merge($relatedQueries, [
-                    Query::limit(PHP_INT_MAX),
-                ])
-            ));
+        return $value;
+    }
 
-            $twoWayKey = $relationship->getAttribute('options')['twoWayKey'];
-            $parentIds = [];
+    /**
+     * Decode Attribute
+     *
+     * Passes the attribute $value, and $document context to a predefined filter
+     *  that allow you to manipulate the output format of the given attribute.
+     *
+     * @throws NotFoundException
+     */
+    protected function decodeAttribute(string $filter, mixed $value, Document $document, string $attribute): mixed
+    {
+        if (! $this->filter) {
+            return $value;
+        }
 
-            foreach ($matchingDocs as $doc) {
-                $parentId = $doc->getAttribute($twoWayKey);
+        if (! \is_null($this->disabledFilters) && isset($this->disabledFilters[$filter])) {
+            return $value;
+        }
 
-                if (\is_array($parentId)) {
-                    foreach ($parentId as $id) {
-                        if ($id instanceof Document) {
-                            $id = $id->getId();
-                        }
-                        if ($id && !\in_array($id, $parentIds)) {
-                            $parentIds[] = $id;
-                        }
-                    }
-                } else {
-                    if ($parentId instanceof Document) {
-                        $parentId = $parentId->getId();
-                    }
-                    if ($parentId && !\in_array($parentId, $parentIds)) {
-                        $parentIds[] = $parentId;
-                    }
-                }
-            }
+        if (! array_key_exists($filter, self::$filters) && ! array_key_exists($filter, $this->instanceFilters)) {
+            throw new NotFoundException("Filter \"{$filter}\" not found for attribute \"{$attribute}\"");
+        }
 
-            return empty($parentIds) ? null : ['attribute' => '$id', 'ids' => $parentIds];
+        if (array_key_exists($filter, $this->instanceFilters)) {
+            $value = $this->instanceFilters[$filter]['decode']($value, $document, $this, $attribute);
         } else {
-            $matchingDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find(
-                $relatedCollection,
-                \array_merge($relatedQueries, [
-                    Query::select(['$id']),
-                    Query::limit(PHP_INT_MAX),
-                ])
-            )));
-
-            $matchingIds = \array_map(fn ($doc) => $doc->getId(), $matchingDocs);
-            return empty($matchingIds) ? null : ['attribute' => $relationshipKey, 'ids' => $matchingIds];
+            $value = self::$filters[$filter]['decode']($value, $document, $this, $attribute);
         }
+
+        return $value;
     }
 
     /**
      * Encode spatial data from array format to WKT (Well-Known Text) format
      *
-     * @param mixed $value
-     * @param string $type
-     * @return string
      * @throws DatabaseException
      */
     protected function encodeSpatialData(mixed $value, string $type): string
     {
-        $validator = new Spatial($type);
-        if (!$validator->isValid($value)) {
+        $validator = new SpatialValidator($type);
+        if (! $validator->isValid($value)) {
             throw new StructureException($validator->getDescription());
         }
 
+        /** @var array<int, array<int, float|int>|array<int, array<int, float|int>>> $value */
         switch ($type) {
-            case self::VAR_POINT:
+            case ColumnType::Point->value:
+                /** @var array{0: float|int, 1: float|int} $value */
                 return "POINT({$value[0]} {$value[1]})";
 
-            case self::VAR_LINESTRING:
+            case ColumnType::Linestring->value:
                 $points = [];
+                /** @var array<int, array{0: float|int, 1: float|int}> $value */
                 foreach ($value as $point) {
                     $points[] = "{$point[0]} {$point[1]}";
                 }
-                return 'LINESTRING(' . implode(', ', $points) . ')';
 
-            case self::VAR_POLYGON:
+                return 'LINESTRING('.implode(', ', $points).')';
+
+            case ColumnType::Polygon->value:
+                /** @var array<int, mixed> $value */
                 // Check if this is a single ring (flat array of points) or multiple rings
                 $isSingleRing = count($value) > 0 && is_array($value[0]) &&
                     count($value[0]) === 2 && is_numeric($value[0][0]) && is_numeric($value[0][1]);
@@ -10773,29 +2752,68 @@ protected function encodeSpatialData(mixed $value, string $type): string
                 }
 
                 $rings = [];
+                /** @var array<int, array<int, array{0: float|int, 1: float|int}>> $value */
                 foreach ($value as $ring) {
                     $points = [];
                     foreach ($ring as $point) {
                         $points[] = "{$point[0]} {$point[1]}";
                     }
-                    $rings[] = '(' . implode(', ', $points) . ')';
+                    $rings[] = '('.implode(', ', $points).')';
                 }
-                return 'POLYGON(' . implode(', ', $rings) . ')';
+
+                return 'POLYGON('.implode(', ', $rings).')';
 
             default:
-                throw new DatabaseException('Unknown spatial type: ' . $type);
+                throw new DatabaseException('Unknown spatial type: '.$type);
+        }
+    }
+
+    /**
+     * Check if values are compatible with object attribute type (hashmap/multi-dimensional array)
+     *
+     * @param  array<mixed>  $values
+     */
+    private function isCompatibleObjectValue(array $values): bool
+    {
+        if (empty($values)) {
+            return false;
+        }
+
+        foreach ($values as $value) {
+            if (! \is_array($value)) {
+                return false;
+            }
+
+            // Check associative array (hashmap) or nested structure
+            if (empty($value)) {
+                continue;
+            }
+
+            // simple indexed array => not an object
+            if (\array_keys($value) === \range(0, \count($value) - 1)) {
+                return false;
+            }
+
+            foreach ($value as $nestedValue) {
+                if (\is_array($nestedValue)) {
+                    continue;
+                }
+            }
         }
+
+        return true;
     }
 
     /**
      * Retry a callable with exponential backoff
      *
-     * @param callable $operation The operation to retry
-     * @param int $maxAttempts Maximum number of retry attempts
-     * @param int $initialDelayMs Initial delay in milliseconds
-     * @param float $multiplier Backoff multiplier
+     * @param  callable  $operation  The operation to retry
+     * @param  int  $maxAttempts  Maximum number of retry attempts
+     * @param  int  $initialDelayMs  Initial delay in milliseconds
+     * @param  float  $multiplier  Backoff multiplier
      * @return void The result of the operation
-     * @throws \Throwable The last exception if all retries fail
+     *
+     * @throws Throwable The last exception if all retries fail
      */
     private function withRetries(
         callable $operation,
@@ -10805,13 +2823,14 @@ private function withRetries(
     ): void {
         $attempt = 0;
         $delayMs = $initialDelayMs;
-        $lastException = null;
+        $lastException = new DatabaseException('All retry attempts failed');
 
         while ($attempt < $maxAttempts) {
             try {
                 $operation();
+
                 return;
-            } catch (\Throwable $e) {
+            } catch (Throwable $e) {
                 $lastException = $e;
                 $attempt++;
 
@@ -10825,7 +2844,7 @@ private function withRetries(
                     \usleep($delayMs * 1000);
                 }
 
-                $delayMs = (int)($delayMs * $multiplier);
+                $delayMs = (int) ($delayMs * $multiplier);
             }
         }
 
@@ -10835,11 +2854,11 @@ private function withRetries(
     /**
      * Generic cleanup operation with retry logic
      *
-     * @param callable $operation The cleanup operation to execute
-     * @param string $resourceType Type of resource being cleaned up (e.g., 'attribute', 'index')
-     * @param string $resourceId ID of the resource being cleaned up
-     * @param int $maxAttempts Maximum retry attempts
-     * @return void
+     * @param  callable  $operation  The cleanup operation to execute
+     * @param  string  $resourceType  Type of resource being cleaned up (e.g., 'attribute', 'index')
+     * @param  string  $resourceId  ID of the resource being cleaned up
+     * @param  int  $maxAttempts  Maximum retry attempts
+     *
      * @throws DatabaseException If cleanup fails after all retries
      */
     private function cleanup(
@@ -10850,34 +2869,12 @@ private function cleanup(
     ): void {
         try {
             $this->withRetries($operation, maxAttempts: $maxAttempts);
-        } catch (\Throwable $e) {
-            Console::error("Failed to cleanup {$resourceType} '{$resourceId}' after {$maxAttempts} attempts: " . $e->getMessage());
+        } catch (Throwable $e) {
+            Console::error("Failed to cleanup {$resourceType} '{$resourceId}' after {$maxAttempts} attempts: ".$e->getMessage());
             throw $e;
         }
     }
 
-    /**
-     * Cleanup (delete) an index with retry logic
-     *
-     * @param string $collectionId The collection ID
-     * @param string $indexId The index ID
-     * @param int $maxAttempts Maximum retry attempts
-     * @return void
-     * @throws DatabaseException If cleanup fails after all retries
-     */
-    private function cleanupIndex(
-        string $collectionId,
-        string $indexId,
-        int $maxAttempts = 3
-    ): void {
-        $this->cleanup(
-            fn () => $this->adapter->deleteIndex($collectionId, $indexId),
-            'index',
-            $indexId,
-            $maxAttempts
-        );
-    }
-
     /**
      * Persist metadata with automatic rollback on failure
      *
@@ -10886,13 +2883,13 @@ private function cleanupIndex(
      * 2. Rolling back database operations if metadata persistence fails
      * 3. Providing detailed error messages for both success and failure scenarios
      *
-     * @param Document $collection The collection document to persist
-     * @param callable|null $rollbackOperation Cleanup operation to run if persistence fails (null if no cleanup needed)
-     * @param bool $shouldRollback Whether rollback should be attempted (e.g., false for duplicates in shared tables)
-     * @param string $operationDescription Description of the operation for error messages
-     * @param bool $rollbackReturnsErrors Whether rollback operation returns error array (true) or throws (false)
-     * @param bool $silentRollback Whether rollback errors should be silently caught (true) or thrown (false)
-     * @return void
+     * @param  Document  $collection  The collection document to persist
+     * @param  callable|null  $rollbackOperation  Cleanup operation to run if persistence fails (null if no cleanup needed)
+     * @param  bool  $shouldRollback  Whether rollback should be attempted (e.g., false for duplicates in shared tables)
+     * @param  string  $operationDescription  Description of the operation for error messages
+     * @param  bool  $rollbackReturnsErrors  Whether rollback operation returns error array (true) or throws (false)
+     * @param  bool  $silentRollback  Whether rollback errors should be silently caught (true) or thrown (false)
+     *
      * @throws DatabaseException If metadata persistence fails after all retries
      */
     private function updateMetadata(
@@ -10906,18 +2903,18 @@ private function updateMetadata(
         try {
             if ($collection->getId() !== self::METADATA) {
                 $this->withRetries(
-                    fn () => $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection))
+                    fn () => $this->skipValidation(fn () => $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection)))
                 );
             }
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             // Attempt rollback only if conditions are met
             if ($shouldRollback && $rollbackOperation !== null) {
                 if ($rollbackReturnsErrors) {
-                    // Batch mode: rollback returns array of errors
+                    /** @var array<string> $cleanupErrors */
                     $cleanupErrors = $rollbackOperation();
-                    if (!empty($cleanupErrors)) {
+                    if (! empty($cleanupErrors)) {
                         throw new DatabaseException(
-                            "Failed to persist metadata after retries and cleanup encountered errors for {$operationDescription}: " . $e->getMessage() . ' | Cleanup errors: ' . implode(', ', $cleanupErrors),
+                            "Failed to persist metadata after retries and cleanup encountered errors for {$operationDescription}: ".$e->getMessage().' | Cleanup errors: '.implode(', ', $cleanupErrors),
                             previous: $e
                         );
                     }
@@ -10925,16 +2922,16 @@ private function updateMetadata(
                     // Silent mode: swallow rollback errors
                     try {
                         $rollbackOperation();
-                    } catch (\Throwable $e) {
+                    } catch (Throwable $e) {
                         // Silent rollback - errors are swallowed
                     }
                 } else {
                     // Regular mode: rollback throws on failure
                     try {
                         $rollbackOperation();
-                    } catch (\Throwable $ex) {
+                    } catch (Throwable $ex) {
                         throw new DatabaseException(
-                            "Failed to persist metadata after retries and cleanup failed for {$operationDescription}: " . $ex->getMessage() . ' | Cleanup error: ' . $e->getMessage(),
+                            "Failed to persist metadata after retries and cleanup failed for {$operationDescription}: ".$ex->getMessage().' | Cleanup error: '.$e->getMessage(),
                             previous: $e
                         );
                     }
@@ -10942,26 +2939,9 @@ private function updateMetadata(
             }
 
             throw new DatabaseException(
-                "Failed to persist metadata after retries for {$operationDescription}: " . $e->getMessage(),
+                "Failed to persist metadata after retries for {$operationDescription}: ".$e->getMessage(),
                 previous: $e
             );
         }
     }
-
-    /**
-     * Rollback metadata state by removing specified attributes from collection
-     *
-     * @param Document $collection The collection document
-     * @param array<string> $attributeIds Attribute IDs to remove
-     * @return void
-     */
-    private function rollbackAttributeMetadata(Document $collection, array $attributeIds): void
-    {
-        $attributes = $collection->getAttribute('attributes', []);
-        $filteredAttributes = \array_filter(
-            $attributes,
-            fn ($attr) => !\in_array($attr->getId(), $attributeIds)
-        );
-        $collection->setAttribute('attributes', \array_values($filteredAttributes));
-    }
 }
diff --git a/src/Database/DateTime.php b/src/Database/DateTime.php
index e5c8850fb4..3492840f8f 100644
--- a/src/Database/DateTime.php
+++ b/src/Database/DateTime.php
@@ -2,11 +2,19 @@
 
 namespace Utopia\Database;
 
+use DateInterval;
+use DateTime as PhpDateTime;
+use DateTimeZone;
+use Throwable;
 use Utopia\Database\Exception as DatabaseException;
 
+/**
+ * Utility class for formatting and manipulating date-time values in the database.
+ */
 class DateTime
 {
     protected static string $formatDb = 'Y-m-d H:i:s.v';
+
     protected static string $formatTz = 'Y-m-d\TH:i:s.vP';
 
     private function __construct()
@@ -14,36 +22,65 @@ private function __construct()
     }
 
     /**
+     * Get the current date-time formatted for database storage.
+     *
      * @return string
      */
     public static function now(): string
     {
-        $date = new \DateTime();
+        $date = new PhpDateTime();
+
         return self::format($date);
     }
 
     /**
-     * @param \DateTime $date
+     * Get the current date-time, advancing by one millisecond when needed.
+     */
+    public static function nowAfter(?string $previous): string
+    {
+        $current = self::format(new PhpDateTime());
+        if ($previous === null) {
+            return $current;
+        }
+
+        try {
+            $date = new PhpDateTime($current);
+            $minimum = new PhpDateTime($previous);
+        } catch (Throwable $error) {
+            throw new DatabaseException($error->getMessage(), $error->getCode(), $error);
+        }
+
+        if ($date <= $minimum) {
+            $minimum->modify('+1 millisecond');
+
+            return self::format($minimum);
+        }
+
+        return $current;
+    }
+
+    /**
+     * Format a DateTime object into the database storage format.
+     *
+     * @param PhpDateTime $date The date to format
      * @return string
      */
-    public static function format(\DateTime $date): string
+    public static function format(PhpDateTime $date): string
     {
         return $date->format(self::$formatDb);
     }
 
     /**
-     * @param \DateTime $date
-     * @param int $seconds
+     * Add seconds to a DateTime and return the formatted result.
+     *
+     * @param PhpDateTime $date The base date
+     * @param int $seconds Number of seconds to add
      * @return string
      * @throws DatabaseException
      */
-    public static function addSeconds(\DateTime $date, int $seconds): string
+    public static function addSeconds(PhpDateTime $date, int $seconds): string
     {
-        $interval  = \DateInterval::createFromDateString($seconds . ' seconds');
-
-        if (!$interval) {
-            throw new DatabaseException('Invalid interval');
-        }
+        $interval = DateInterval::createFromDateString($seconds.' seconds');
 
         $date->add($interval);
 
@@ -51,24 +88,29 @@ public static function addSeconds(\DateTime $date, int $seconds): string
     }
 
     /**
-     * @param string $datetime
+     * Parse a datetime string and convert it to the system's default timezone.
+     *
+     * @param string $datetime The datetime string to convert
      * @return string
      * @throws DatabaseException
      */
     public static function setTimezone(string $datetime): string
     {
         try {
-            $value = new \DateTime($datetime);
-            $value->setTimezone(new \DateTimeZone(date_default_timezone_get()));
+            $value = new PhpDateTime($datetime);
+            $value->setTimezone(new DateTimeZone(date_default_timezone_get()));
+
             return DateTime::format($value);
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
         }
     }
 
     /**
-     * @param string|null $dbFormat
-     * @return string|null
+     * Convert a database-format date string to a timezone-aware ISO 8601 format.
+     *
+     * @param string|null $dbFormat The date string in database format, or null
+     * @return string|null The formatted date string with timezone, or null if input is null
      */
     public static function formatTz(?string $dbFormat): ?string
     {
@@ -77,9 +119,10 @@ public static function formatTz(?string $dbFormat): ?string
         }
 
         try {
-            $value = new \DateTime($dbFormat);
+            $value = new PhpDateTime($dbFormat);
+
             return $value->format(self::$formatTz);
-        } catch (\Throwable) {
+        } catch (Throwable) {
             return $dbFormat;
         }
     }
diff --git a/src/Database/Document.php b/src/Database/Document.php
index 73bd458cd5..625cb648a5 100644
--- a/src/Database/Document.php
+++ b/src/Database/Document.php
@@ -7,50 +7,101 @@
 use Utopia\Database\Exception\Structure as StructureException;
 
 /**
+ * Represents a database document as an array-accessible object with support for nested documents and permissions.
+ *
  * @extends ArrayObject<string, mixed>
  */
 class Document extends ArrayObject
 {
-    public const SET_TYPE_ASSIGN = 'assign';
-    public const SET_TYPE_PREPEND = 'prepend';
-    public const SET_TYPE_APPEND = 'append';
+    public const string ID = '$id';
 
+    public const string SEQUENCE = '$sequence';
+
+    public const string COLLECTION = '$collection';
+
+    public const string CREATED_AT = '$createdAt';
+
+    public const string UPDATED_AT = '$updatedAt';
+
+    public const string PERMISSIONS = '$permissions';
+
+    public const string TENANT = '$tenant';
+
+    public const string VERSION = '$version';
+
+    public const string DISTANCE = '$distance';
+
+    public const string DELETED_AT = '$deletedAt';
+
+    public const string SKIP_PERMISSIONS_UPDATE = '$skipPermissionsUpdate';
+
+    public const string INTERNAL_ID = '$internalId';
+
+    /** @var array<string, true>|null */
+    private static ?array $internalKeySet = null;
+
+    /** @var array<string, list<string>>|null */
+    private ?array $parsedPermissions = null;
+
+    /**
+     * @return array<string, true>
+     */
+    private static function getInternalKeySet(): array
+    {
+        if (self::$internalKeySet === null) {
+            self::$internalKeySet = [];
+            foreach (Database::internalAttributes() as $attr) {
+                self::$internalKeySet[$attr->key] = true;
+            }
+        }
+        return self::$internalKeySet;
+    }
     /**
      * Construct.
      *
      * Construct a new fields object
      *
-     * @param array<string, mixed> $input
+     * @param  array<string, mixed>  $input
+     *
      * @throws DatabaseException
-     * @see ArrayObject::__construct
      *
+     * @see ArrayObject::__construct
      */
     public function __construct(array $input = [])
     {
-        if (array_key_exists('$id', $input) && !\is_string($input['$id'])) {
-            throw new StructureException('$id must be of type string');
+        if (array_key_exists(self::ID, $input) && ! \is_string($input[self::ID])) {
+            throw new StructureException(self::ID.' must be of type string');
         }
 
-        if (array_key_exists('$permissions', $input) && !is_array($input['$permissions'])) {
-            throw new StructureException('$permissions must be of type array');
+        if (array_key_exists(self::PERMISSIONS, $input) && ! is_array($input[self::PERMISSIONS])) {
+            throw new StructureException(self::PERMISSIONS.' must be of type array');
+        }
+
+        if (array_key_exists(self::PERMISSIONS, $input) && is_array($input[self::PERMISSIONS])) {
+            $permissions = [];
+            foreach ($input[self::PERMISSIONS] as $permission) {
+                if (\is_string($permission)) {
+                    $permissions[] = $permission;
+                }
+            }
+            $input[self::PERMISSIONS] = \array_values(\array_unique($permissions));
         }
 
         foreach ($input as $key => $value) {
-            if (!\is_array($value)) {
+            if (! \is_array($value)) {
                 continue;
             }
 
-            if (isset($value['$id']) || isset($value['$collection'])) {
+            if (isset($value[self::ID]) || isset($value[self::COLLECTION])) {
+                /** @var array<string, mixed> $value */
                 $input[$key] = new self($value);
+
                 continue;
             }
 
             foreach ($value as $childKey => $child) {
-                // An array value is either a list of nested sub-documents or a list of
-                // plain items (dates, numbers, strings): wrap the former, leave the latter.
-                // is_array() tells them apart and avoids array-accessing a non-array
-                // value (e.g. a UTCDateTime), which would otherwise fatal.
-                if (\is_array($child) && (isset($child['$id']) || isset($child['$collection']))) {
+                if (\is_array($child) && (isset($child[self::ID]) || isset($child[self::COLLECTION]))) {
+                    /** @var array<string, mixed> $child */
                     $value[$childKey] = new self($child);
                 }
             }
@@ -62,76 +113,155 @@ public function __construct(array $input = [])
     }
 
     /**
-     * @return string
+     * @param  array<string, mixed>  $data
+     */
+    public static function fromArray(array $data): self
+    {
+        $class = static::class;
+
+        return new $class($data);
+    }
+
+    /**
+     * Construct from a raw PDO row.
+     *
+     * Fast path that skips nested-Document detection. Raw PDO rows from
+     * `$stmt->fetch()` only contain scalars or JSON-encoded strings — there
+     * are never nested arrays carrying `$id`/`$collection`, so the
+     * nested-detection foreach in the constructor is pure waste per row.
+     *
+     * Callers that build documents from relationship-resolved trees or
+     * arbitrary user input must continue to use the regular constructor.
+     *
+     * @param  array<string, mixed>  $row
+     *
+     * @throws DatabaseException
+     */
+    public static function fromRow(array $row): self
+    {
+        if (array_key_exists(self::ID, $row)) {
+            if ($row[self::ID] === null) {
+                $row[self::ID] = '';
+            } elseif (! \is_string($row[self::ID])) {
+                throw new StructureException(self::ID.' must be of type string');
+            }
+        }
+
+        if (array_key_exists(self::PERMISSIONS, $row)) {
+            if (! \is_array($row[self::PERMISSIONS])) {
+                throw new StructureException(self::PERMISSIONS.' must be of type array');
+            }
+            $permissions = [];
+            foreach ($row[self::PERMISSIONS] as $permission) {
+                if (\is_string($permission)) {
+                    $permissions[] = $permission;
+                }
+            }
+            $row[self::PERMISSIONS] = \array_values(\array_unique($permissions));
+        }
+
+        $document = new self();
+        $document->exchangeArray($row);
+
+        return $document;
+    }
+
+    /**
+     * Get the document's unique identifier.
+     *
+     * @return string The document ID, or empty string if not set.
      */
     public function getId(): string
     {
-        return $this->getAttribute('$id', '');
+        /** @var string $id */
+        $id = $this->getAttribute(self::ID, '');
+        return $id;
     }
 
     /**
-     * @return string|null
+     * Get the document's auto-generated sequence identifier.
+     *
+     * @return string|null The sequence value, or null if not set.
      */
     public function getSequence(): ?string
     {
-        $sequence = $this->getAttribute('$sequence');
+        $sequence = $this->getAttribute(self::SEQUENCE);
 
         if ($sequence === null) {
             return null;
         }
 
+        /** @var string $sequence */
         return $sequence;
     }
 
     /**
-     * @return string
+     * Get the collection ID this document belongs to.
+     *
+     * @return string The collection ID, or empty string if not set.
      */
     public function getCollection(): string
     {
-        return $this->getAttribute('$collection', '');
+        /** @var string $collection */
+        $collection = $this->getAttribute(self::COLLECTION, '');
+        return $collection;
     }
 
     /**
+     * Get all unique permissions assigned to this document.
+     *
      * @return array<string>
      */
     public function getPermissions(): array
     {
-        return \array_values(\array_unique($this->getAttribute('$permissions', [])));
+        /** @var array<string> $permissions */
+        $permissions = $this->getAttribute(self::PERMISSIONS, []);
+        return $permissions;
     }
 
     /**
+     * Get roles with read permission on this document.
+     *
      * @return array<string>
      */
     public function getRead(): array
     {
-        return $this->getPermissionsByType(Database::PERMISSION_READ);
+        return $this->getPermissionsByType(PermissionType::Read);
     }
 
     /**
+     * Get roles with create permission on this document.
+     *
      * @return array<string>
      */
     public function getCreate(): array
     {
-        return $this->getPermissionsByType(Database::PERMISSION_CREATE);
+        return $this->getPermissionsByType(PermissionType::Create);
     }
 
     /**
+     * Get roles with update permission on this document.
+     *
      * @return array<string>
      */
     public function getUpdate(): array
     {
-        return $this->getPermissionsByType(Database::PERMISSION_UPDATE);
+        return $this->getPermissionsByType(PermissionType::Update);
     }
 
     /**
+     * Get roles with delete permission on this document.
+     *
      * @return array<string>
      */
     public function getDelete(): array
     {
-        return $this->getPermissionsByType(Database::PERMISSION_DELETE);
+        return $this->getPermissionsByType(PermissionType::Delete);
     }
 
     /**
+     * Get roles with full write permission (create, update, and delete) on this document.
+     *
      * @return array<string>
      */
     public function getWrite(): array
@@ -144,50 +274,93 @@ public function getWrite(): array
     }
 
     /**
+     * Get roles for a specific permission type from this document's permissions.
+     *
+     * @param PermissionType $type The permission type.
      * @return array<string>
      */
-    public function getPermissionsByType(string $type): array
+    public function getPermissionsByType(PermissionType $type): array
     {
-        $typePermissions = [];
-
-        foreach ($this->getPermissions() as $permission) {
-            if (!\str_starts_with($permission, $type)) {
-                continue;
+        if ($this->parsedPermissions === null) {
+            $this->parsedPermissions = [];
+            foreach ($this->getPermissions() as $permission) {
+                foreach (PermissionType::cases() as $permissionType) {
+                    $t = $permissionType->value;
+                    if (\str_starts_with($permission, $t)) {
+                        $this->parsedPermissions[$t][] = \str_replace([$t.'(', ')', '"', ' '], '', $permission);
+                        break;
+                    }
+                }
+            }
+            foreach ($this->parsedPermissions as &$roles) {
+                $roles = \array_values(\array_unique($roles));
             }
-            $typePermissions[] = \str_replace([$type . '(', ')', '"', ' '], '', $permission);
         }
-
-        return \array_unique($typePermissions);
+        return $this->parsedPermissions[$type->value] ?? [];
     }
 
     /**
-     * @return string|null
+     * Get the document's creation timestamp.
+     *
+     * @return string|null The creation datetime string, or null if not set.
      */
     public function getCreatedAt(): ?string
     {
-        return $this->getAttribute('$createdAt');
+        /** @var string|null $createdAt */
+        $createdAt = $this->getAttribute(self::CREATED_AT);
+        return $createdAt;
     }
 
     /**
-     * @return string|null
+     * Get the document's last update timestamp.
+     *
+     * @return string|null The update datetime string, or null if not set.
      */
     public function getUpdatedAt(): ?string
     {
-        return $this->getAttribute('$updatedAt');
+        /** @var string|null $updatedAt */
+        $updatedAt = $this->getAttribute(self::UPDATED_AT);
+        return $updatedAt;
     }
 
     /**
-     * @return int|string|null
+     * Get the tenant ID associated with this document.
+     *
+     * Numeric string values are normalized to int for consistent comparison
+     * across adapters that may return string representations (e.g. PDO stringify).
+     *
+     * @return int|string|null The tenant ID, or null if not set.
      */
     public function getTenant(): int|string|null
     {
-        $tenant = $this->getAttribute('$tenant');
+        $tenant = $this->getAttribute(self::TENANT);
 
-        if (\is_numeric($tenant)) {
+        if (\is_string($tenant) && \ctype_digit($tenant)) {
             return (int) $tenant;
         }
 
-        return $tenant;
+        if (\is_int($tenant) || \is_string($tenant) || $tenant === null) {
+            return $tenant;
+        }
+
+        return null;
+    }
+
+    /**
+     * Get the document's optimistic locking version.
+     *
+     * @return int|null The version number, or null if not set.
+     */
+    public function getVersion(): ?int
+    {
+        $version = $this->getAttribute(self::VERSION);
+
+        if ($version === null) {
+            return null;
+        }
+
+        /** @var int $version */
+        return $version;
     }
 
     /**
@@ -198,14 +371,10 @@ public function getTenant(): int|string|null
     public function getAttributes(): array
     {
         $attributes = [];
-
-        $internalKeys = \array_map(
-            fn ($attr) => $attr['$id'],
-            Database::INTERNAL_ATTRIBUTES
-        );
+        $keySet = self::getInternalKeySet();
 
         foreach ($this as $attribute => $value) {
-            if (\in_array($attribute, $internalKeys)) {
+            if (isset($keySet[$attribute])) {
                 continue;
             }
 
@@ -219,11 +388,6 @@ public function getAttributes(): array
      * Get Attribute.
      *
      * Method for getting a specific fields attribute. If $name is not found $default value will be returned.
-     *
-     * @param string $name
-     * @param mixed $default
-     *
-     * @return mixed
      */
     public function getAttribute(string $name, mixed $default = null): mixed
     {
@@ -234,31 +398,93 @@ public function getAttribute(string $name, mixed $default = null): mixed
         return $default;
     }
 
+    /**
+     * @return array<int|string, mixed>
+     */
+    public function getArray(string $key): array
+    {
+        $value = $this->offsetExists($key) ? $this[$key] : [];
+
+        return \is_array($value) ? $value : [];
+    }
+
+    /**
+     * @return list<self>
+     */
+    public function getDocuments(string $key): array
+    {
+        $documents = [];
+        foreach ($this->getArray($key) as $item) {
+            if ($item instanceof self) {
+                $documents[] = $item;
+                continue;
+            }
+            if (! \is_array($item)) {
+                continue;
+            }
+            $typed = [];
+            foreach ($item as $name => $value) {
+                if (\is_string($name)) {
+                    $typed[$name] = $value;
+                }
+            }
+            $documents[] = new self($typed);
+        }
+
+        return $documents;
+    }
+
+    public function getDocument(string $key): self
+    {
+        $value = $this->offsetExists($key) ? $this[$key] : null;
+        if ($value instanceof self) {
+            return $value;
+        }
+        if (! \is_array($value) || $value === [] || \array_is_list($value)) {
+            return new self();
+        }
+
+        $typed = [];
+        foreach ($value as $name => $item) {
+            if (\is_string($name)) {
+                $typed[$name] = $item;
+            }
+        }
+
+        return new self($typed);
+    }
+
     /**
      * Set Attribute.
      *
      * Method for setting a specific field attribute
-     *
-     * @param string $key
-     * @param mixed $value
-     * @param string $type
-     *
-     * @return static
-     */
-    public function setAttribute(string $key, mixed $value, string $type = self::SET_TYPE_ASSIGN): static
-    {
-        switch ($type) {
-            case self::SET_TYPE_ASSIGN:
-                $this[$key] = $value;
-                break;
-            case self::SET_TYPE_APPEND:
-                $this[$key] = (!isset($this[$key]) || !\is_array($this[$key])) ? [] : $this[$key];
-                \array_push($this[$key], $value);
-                break;
-            case self::SET_TYPE_PREPEND:
-                $this[$key] = (!isset($this[$key]) || !\is_array($this[$key])) ? [] : $this[$key];
-                \array_unshift($this[$key], $value);
-                break;
+     */
+    public function setAttribute(string $key, mixed $value, SetType $type = SetType::Assign): static
+    {
+        // Fast path for the dominant Assign case — skip the match dispatch
+        // and the type-comparison branches that only matter for Append/Prepend.
+        if ($type === SetType::Assign) {
+            $this[$key] = $value;
+        } else {
+            $this[$key] = (! isset($this[$key]) || ! \is_array($this[$key])) ? [] : $this[$key];
+
+            match ($type) {
+                SetType::Append => $this[$key] = [...(array) $this[$key], $value],
+                SetType::Prepend => $this[$key] = [$value, ...(array) $this[$key]],
+            };
+        }
+
+        if ($key === self::PERMISSIONS) {
+            if (\is_array($this[$key])) {
+                $permissions = [];
+                foreach ($this[$key] as $permission) {
+                    if (\is_string($permission)) {
+                        $permissions[] = $permission;
+                    }
+                }
+                $this[$key] = \array_values(\array_unique($permissions));
+            }
+            $this->parsedPermissions = null;
         }
 
         return $this;
@@ -267,8 +493,7 @@ public function setAttribute(string $key, mixed $value, string $type = self::SET
     /**
      * Set Attributes.
      *
-     * @param array<string, mixed> $attributes
-     * @return static
+     * @param  array<string, mixed>  $attributes
      */
     public function setAttributes(array $attributes): static
     {
@@ -283,45 +508,42 @@ public function setAttributes(array $attributes): static
      * Remove Attribute.
      *
      * Method for removing a specific field attribute
-     *
-     * @param string $key
-     *
-     * @return static
      */
     public function removeAttribute(string $key): static
     {
-        unset($this[$key]);
+        $this->offsetUnset($key);
 
-        /* @phpstan-ignore-next-line */
         return $this;
     }
 
     /**
      * Find.
      *
-     * @param string $key
-     * @param mixed $find
-     * @param string $subject
-     *
-     * @return mixed
+     * @param  mixed  $find
      */
     public function find(string $key, $find, string $subject = ''): mixed
     {
-        $subject = $this[$subject] ?? null;
-        $subject = (empty($subject)) ? $this : $subject;
+        $subjectData = !empty($subject) ? ($this[$subject] ?? null) : null;
+        /** @var array<mixed>|self $resolved */
+        $resolved = (empty($subjectData)) ? $this : $subjectData;
 
-        if (is_array($subject)) {
-            foreach ($subject as $i => $value) {
-                if (isset($value[$key]) && $value[$key] === $find) {
+        if (is_array($resolved)) {
+            foreach ($resolved as $i => $value) {
+                if (\is_array($value) && isset($value[$key]) && $value[$key] === $find) {
+                    return $value;
+                }
+                if ($value instanceof self && isset($value[$key]) && $value[$key] === $find) {
                     return $value;
                 }
             }
+
             return false;
         }
 
-        if (isset($subject[$key]) && $subject[$key] === $find) {
-            return $subject;
+        if (isset($resolved[$key]) && $resolved[$key] === $find) {
+            return $resolved;
         }
+
         return false;
     }
 
@@ -330,32 +552,45 @@ public function find(string $key, $find, string $subject = ''): mixed
      *
      * Get array child by key and value match
      *
-     * @param string $key
-     * @param mixed $find
-     * @param mixed $replace
-     * @param string $subject
-     *
-     * @return bool
+     * @param  mixed  $find
+     * @param  mixed  $replace
      */
     public function findAndReplace(string $key, $find, $replace, string $subject = ''): bool
     {
-        $subject = &$this[$subject] ?? null;
-        $subject = (empty($subject)) ? $this : $subject;
-
-        if (is_array($subject)) {
-            foreach ($subject as $i => &$value) {
-                if (isset($value[$key]) && $value[$key] === $find) {
+        if (!empty($subject) && isset($this[$subject]) && \is_array($this[$subject])) {
+            /** @var array<mixed> $subjectArray */
+            $subjectArray = &$this[$subject];
+            foreach ($subjectArray as $i => &$value) {
+                if (\is_array($value) && isset($value[$key]) && $value[$key] === $find) {
                     $value = $replace;
                     return true;
                 }
+                if ($value instanceof self && isset($value[$key]) && $value[$key] === $find) {
+                    $subjectArray[$i] = $replace;
+                    return true;
+                }
             }
             return false;
         }
 
-        if (isset($subject[$key]) && $subject[$key] === $find) {
-            $subject[$key] = $replace;
+        /** @var self $resolved */
+        $resolved = $this;
+        foreach ($resolved as $i => $value) {
+            if (\is_array($value) && isset($value[$key]) && $value[$key] === $find) {
+                $resolved[$i] = $replace;
+                return true;
+            }
+            if ($value instanceof self && isset($value[$key]) && $value[$key] === $find) {
+                $resolved[$i] = $replace;
+                return true;
+            }
+        }
+
+        if (isset($resolved[$key]) && $resolved[$key] === $find) {
+            $resolved[$key] = $replace;
             return true;
         }
+
         return false;
     }
 
@@ -364,50 +599,57 @@ public function findAndReplace(string $key, $find, $replace, string $subject = '
      *
      * Get array child by key and value match
      *
-     * @param string $key
-     * @param mixed $find
-     * @param string $subject
-     *
-     * @return bool
+     * @param  mixed  $find
      */
     public function findAndRemove(string $key, $find, string $subject = ''): bool
     {
-        $subject = &$this[$subject] ?? null;
-        $subject = (empty($subject)) ? $this : $subject;
-
-        if (is_array($subject)) {
-            foreach ($subject as $i => &$value) {
-                if (isset($value[$key]) && $value[$key] === $find) {
-                    unset($subject[$i]);
+        if (!empty($subject) && isset($this[$subject]) && \is_array($this[$subject])) {
+            /** @var array<mixed> $subjectArray */
+            $subjectArray = &$this[$subject];
+            foreach ($subjectArray as $i => &$value) {
+                if (\is_array($value) && isset($value[$key]) && $value[$key] === $find) {
+                    unset($subjectArray[$i]);
+                    return true;
+                }
+                if ($value instanceof self && isset($value[$key]) && $value[$key] === $find) {
+                    unset($subjectArray[$i]);
                     return true;
                 }
             }
             return false;
         }
 
-        if (isset($subject[$key]) && $subject[$key] === $find) {
-            unset($subject[$key]);
+        /** @var self $resolved */
+        $resolved = $this;
+        foreach ($resolved as $i => $value) {
+            if (\is_array($value) && isset($value[$key]) && $value[$key] === $find) {
+                unset($resolved[$i]);
+                return true;
+            }
+            if ($value instanceof self && isset($value[$key]) && $value[$key] === $find) {
+                unset($resolved[$i]);
+                return true;
+            }
+        }
+
+        if (isset($resolved[$key]) && $resolved[$key] === $find) {
+            unset($resolved[$key]);
             return true;
         }
+
         return false;
     }
 
     /**
      * Checks if document has data.
-     *
-     * @return bool
      */
     public function isEmpty(): bool
     {
-        return !\count($this);
+        return ! \count($this);
     }
 
     /**
      * Checks if a document key is set.
-     *
-     * @param string $key
-     *
-     * @return bool
      */
     public function isSet(string $key): bool
     {
@@ -419,9 +661,8 @@ public function isSet(string $key): bool
      *
      * Outputs entity as a PHP array
      *
-     * @param array<string> $allow
-     * @param array<string> $disallow
-     *
+     * @param  array<string>  $allow
+     * @param  array<string>  $disallow
      * @return array<string, mixed>
      */
     public function getArrayCopy(array $allow = [], array $disallow = []): array
@@ -431,27 +672,29 @@ public function getArrayCopy(array $allow = [], array $disallow = []): array
         $output = [];
 
         foreach ($array as $key => &$value) {
-            if (!empty($allow) && !\in_array($key, $allow)) { // Export only allow fields
+            if (! empty($allow) && ! \in_array($key, $allow)) { // Export only allow fields
                 continue;
             }
 
-            if (!empty($disallow) && \in_array($key, $disallow)) { // Don't export disallowed fields
+            if (! empty($disallow) && \in_array($key, $disallow)) { // Don't export disallowed fields
                 continue;
             }
 
             if ($value instanceof self) {
                 $output[$key] = $value->getArrayCopy($allow, $disallow);
             } elseif (\is_array($value)) {
-                foreach ($value as $childKey => &$child) {
-                    if ($child instanceof self) {
-                        $output[$key][$childKey] = $child->getArrayCopy($allow, $disallow);
-                    } else {
-                        $output[$key][$childKey] = $child;
-                    }
-                }
-
                 if (empty($value)) {
                     $output[$key] = $value;
+                } else {
+                    $childOutput = [];
+                    foreach ($value as $childKey => $child) {
+                        if ($child instanceof self) {
+                            $childOutput[$childKey] = $child->getArrayCopy($allow, $disallow);
+                        } else {
+                            $childOutput[$childKey] = $child;
+                        }
+                    }
+                    $output[$key] = $childOutput;
                 }
             } else {
                 $output[$key] = $value;
@@ -461,6 +704,9 @@ public function getArrayCopy(array $allow = [], array $disallow = []): array
         return $output;
     }
 
+    /**
+     * Deep clone the document including nested Document instances.
+     */
     public function __clone()
     {
         foreach ($this as $key => $value) {
diff --git a/src/Database/Event.php b/src/Database/Event.php
new file mode 100644
index 0000000000..2c8605fa54
--- /dev/null
+++ b/src/Database/Event.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the lifecycle events that can be triggered during database operations.
+ */
+enum Event: string
+{
+    case All = '*';
+    case DatabaseList = 'database_list';
+    case DatabaseCreate = 'database_create';
+    case DatabaseDelete = 'database_delete';
+    case CollectionList = 'collection_list';
+    case CollectionCreate = 'collection_create';
+    case CollectionUpdate = 'collection_update';
+    case CollectionRead = 'collection_read';
+    case CollectionDelete = 'collection_delete';
+    case DocumentFind = 'document_find';
+    case DocumentPurge = 'document_purge';
+    case DocumentCreate = 'document_create';
+    case DocumentsCreate = 'documents_create';
+    case DocumentRead = 'document_read';
+    case DocumentUpdate = 'document_update';
+    case DocumentsUpdate = 'documents_update';
+    case DocumentsUpsert = 'documents_upsert';
+    case DocumentDelete = 'document_delete';
+    case DocumentsDelete = 'documents_delete';
+    case DocumentCount = 'document_count';
+    case DocumentSum = 'document_sum';
+    case DocumentIncrease = 'document_increase';
+    case DocumentDecrease = 'document_decrease';
+    case PermissionsCreate = 'permissions_create';
+    case PermissionsRead = 'permissions_read';
+    case PermissionsDelete = 'permissions_delete';
+    case AttributeCreate = 'attribute_create';
+    case AttributesCreate = 'attributes_create';
+    case AttributeUpdate = 'attribute_update';
+    case AttributeDelete = 'attribute_delete';
+    case IndexRename = 'index_rename';
+    case IndexCreate = 'index_create';
+    case IndexDelete = 'index_delete';
+}
diff --git a/src/Database/Event/Collection/Created.php b/src/Database/Event/Collection/Created.php
new file mode 100644
index 0000000000..3838f83e12
--- /dev/null
+++ b/src/Database/Event/Collection/Created.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\Event\Collection;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\Domain;
+
+class Created extends Domain
+{
+    public function __construct(
+        string $collection,
+        public readonly Document $document,
+    ) {
+        parent::__construct($collection, Event::CollectionCreate);
+    }
+}
diff --git a/src/Database/Event/Collection/Deleted.php b/src/Database/Event/Collection/Deleted.php
new file mode 100644
index 0000000000..323b60efcc
--- /dev/null
+++ b/src/Database/Event/Collection/Deleted.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Utopia\Database\Event\Collection;
+
+use Utopia\Database\Event;
+use Utopia\Database\Event\Domain;
+
+class Deleted extends Domain
+{
+    public function __construct(
+        string $collection,
+    ) {
+        parent::__construct($collection, Event::CollectionDelete);
+    }
+}
diff --git a/src/Database/Event/DispatcherHook.php b/src/Database/Event/DispatcherHook.php
new file mode 100644
index 0000000000..ebd34e53d8
--- /dev/null
+++ b/src/Database/Event/DispatcherHook.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\Collection\Created as CollectionCreated;
+use Utopia\Database\Event\Collection\Deleted as CollectionDeleted;
+use Utopia\Database\Event\Document\Created as DocumentCreated;
+use Utopia\Database\Event\Document\Deleted as DocumentDeleted;
+use Utopia\Database\Event\Document\Updated as DocumentUpdated;
+use Utopia\Database\Hook\Lifecycle;
+
+class DispatcherHook implements Lifecycle
+{
+    /** @var array<string, array<callable>> */
+    private array $listeners = [];
+
+    private ?object $psr14Dispatcher;
+
+    public function __construct(?object $psr14Dispatcher = null)
+    {
+        $this->psr14Dispatcher = $psr14Dispatcher;
+    }
+
+    public function on(string $eventClass, callable $listener): void
+    {
+        $this->listeners[$eventClass][] = $listener;
+    }
+
+    public function handle(Event $event, mixed $data): void
+    {
+        $domainEvent = $this->createDomainEvent($event, $data);
+
+        if ($domainEvent === null) {
+            return;
+        }
+
+        $class = $domainEvent::class;
+        foreach ($this->listeners[$class] ?? [] as $listener) {
+            try {
+                $listener($domainEvent);
+            } catch (\Throwable) {
+            }
+        }
+
+        if ($this->psr14Dispatcher !== null && \method_exists($this->psr14Dispatcher, 'dispatch')) {
+            try {
+                $this->psr14Dispatcher->dispatch($domainEvent);
+            } catch (\Throwable) {
+            }
+        }
+    }
+
+    private function createDomainEvent(Event $event, mixed $data): ?Domain
+    {
+        return match ($event) {
+            Event::DocumentCreate, Event::DocumentsCreate => $data instanceof Document
+                ? new DocumentCreated($data->getCollection(), $data)
+                : null,
+            Event::DocumentUpdate, Event::DocumentsUpdate => $data instanceof Document
+                ? new DocumentUpdated($data->getCollection(), $data)
+                : null,
+            Event::DocumentDelete, Event::DocumentsDelete => $data instanceof Document
+                ? new DocumentDeleted($data->getCollection(), $data->getId())
+                : ($data instanceof \stdClass
+                    && \is_string($data->collection ?? null)
+                    && \is_string($data->id ?? null)
+                    ? new DocumentDeleted($data->collection, $data->id)
+                    : null),
+            Event::CollectionCreate => $data instanceof Document
+                ? new CollectionCreated($data->getId(), $data)
+                : null,
+            Event::CollectionDelete => \is_string($data)
+                ? new CollectionDeleted($data)
+                : null,
+            default => null,
+        };
+    }
+}
diff --git a/src/Database/Event/Document/Created.php b/src/Database/Event/Document/Created.php
new file mode 100644
index 0000000000..d573f0ce08
--- /dev/null
+++ b/src/Database/Event/Document/Created.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\Event\Document;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\Domain;
+
+class Created extends Domain
+{
+    public function __construct(
+        string $collection,
+        public readonly Document $document,
+    ) {
+        parent::__construct($collection, Event::DocumentCreate);
+    }
+}
diff --git a/src/Database/Event/Document/Deleted.php b/src/Database/Event/Document/Deleted.php
new file mode 100644
index 0000000000..3904966457
--- /dev/null
+++ b/src/Database/Event/Document/Deleted.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Utopia\Database\Event\Document;
+
+use Utopia\Database\Event;
+use Utopia\Database\Event\Domain;
+
+class Deleted extends Domain
+{
+    public function __construct(
+        string $collection,
+        public readonly string $documentId,
+    ) {
+        parent::__construct($collection, Event::DocumentDelete);
+    }
+}
diff --git a/src/Database/Event/Document/Updated.php b/src/Database/Event/Document/Updated.php
new file mode 100644
index 0000000000..26daee5b7a
--- /dev/null
+++ b/src/Database/Event/Document/Updated.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Event\Document;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\Domain;
+
+class Updated extends Domain
+{
+    public function __construct(
+        string $collection,
+        public readonly Document $document,
+        public readonly ?Document $previous = null,
+    ) {
+        parent::__construct($collection, Event::DocumentUpdate);
+    }
+}
diff --git a/src/Database/Event/Domain.php b/src/Database/Event/Domain.php
new file mode 100644
index 0000000000..fe3a9d6e86
--- /dev/null
+++ b/src/Database/Event/Domain.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Event;
+
+class Domain
+{
+    public readonly \DateTimeImmutable $occurredAt;
+
+    public function __construct(
+        public readonly string $collection,
+        public readonly Event $event,
+        ?\DateTimeImmutable $occurredAt = null,
+    ) {
+        $this->occurredAt = $occurredAt ?? new \DateTimeImmutable();
+    }
+}
diff --git a/src/Database/Exception.php b/src/Database/Exception.php
index d86e94c2bb..f9bd10a9ff 100644
--- a/src/Database/Exception.php
+++ b/src/Database/Exception.php
@@ -2,10 +2,19 @@
 
 namespace Utopia\Database;
 
+use Exception as PhpException;
 use Throwable;
 
-class Exception extends \Exception
+/**
+ * Base exception class for all database-related errors.
+ */
+class Exception extends PhpException
 {
+    /**
+     * @param string $message The exception message
+     * @param int|string $code The exception code (strings are cast to int)
+     * @param Throwable|null $previous The previous throwable for chaining
+     */
     public function __construct(string $message, int|string $code = 0, ?Throwable $previous = null)
     {
         if (\is_string($code)) {
diff --git a/src/Database/Exception/Authorization.php b/src/Database/Exception/Authorization.php
index a7ab33a7c2..1689f8844c 100644
--- a/src/Database/Exception/Authorization.php
+++ b/src/Database/Exception/Authorization.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database operation fails due to insufficient permissions.
+ */
 class Authorization extends Exception
 {
 }
diff --git a/src/Database/Exception/Character.php b/src/Database/Exception/Character.php
index bf184803ac..e308ca36d6 100644
--- a/src/Database/Exception/Character.php
+++ b/src/Database/Exception/Character.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a value contains invalid or unsupported characters.
+ */
 class Character extends Exception
 {
 }
diff --git a/src/Database/Exception/Conflict.php b/src/Database/Exception/Conflict.php
index 8803bf9023..b0a8d67469 100644
--- a/src/Database/Exception/Conflict.php
+++ b/src/Database/Exception/Conflict.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database operation encounters a conflict, such as a concurrent modification.
+ */
 class Conflict extends Exception
 {
 }
diff --git a/src/Database/Exception/Dependency.php b/src/Database/Exception/Dependency.php
index 5c58ef63cd..b7a33dd9a5 100644
--- a/src/Database/Exception/Dependency.php
+++ b/src/Database/Exception/Dependency.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database operation cannot proceed due to an unresolved dependency.
+ */
 class Dependency extends Exception
 {
 }
diff --git a/src/Database/Exception/Duplicate.php b/src/Database/Exception/Duplicate.php
index 9fc1e907e0..2f15a06894 100644
--- a/src/Database/Exception/Duplicate.php
+++ b/src/Database/Exception/Duplicate.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when attempting to create a resource that already exists.
+ */
 class Duplicate extends Exception
 {
 }
diff --git a/src/Database/Exception/Index.php b/src/Database/Exception/Index.php
index 65524c9262..70dd72db65 100644
--- a/src/Database/Exception/Index.php
+++ b/src/Database/Exception/Index.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database index operation fails or an index constraint is violated.
+ */
 class Index extends Exception
 {
 }
diff --git a/src/Database/Exception/Limit.php b/src/Database/Exception/Limit.php
index 7a5bc0f6b8..25228b68c6 100644
--- a/src/Database/Exception/Limit.php
+++ b/src/Database/Exception/Limit.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database operation exceeds a configured limit (e.g. max documents, max attributes).
+ */
 class Limit extends Exception
 {
 }
diff --git a/src/Database/Exception/NotFound.php b/src/Database/Exception/NotFound.php
index a7e7168f60..2794a744cd 100644
--- a/src/Database/Exception/NotFound.php
+++ b/src/Database/Exception/NotFound.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a requested resource (database, collection, or document) cannot be found.
+ */
 class NotFound extends Exception
 {
 }
diff --git a/src/Database/Exception/Operator.php b/src/Database/Exception/Operator.php
index 781afcb868..fb26941f44 100644
--- a/src/Database/Exception/Operator.php
+++ b/src/Database/Exception/Operator.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when an invalid or unsupported query operator is used.
+ */
 class Operator extends Exception
 {
 }
diff --git a/src/Database/Exception/Order.php b/src/Database/Exception/Order.php
index 0ab49094ef..e356766ce7 100644
--- a/src/Database/Exception/Order.php
+++ b/src/Database/Exception/Order.php
@@ -5,14 +5,30 @@
 use Throwable;
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a query order clause is invalid or references an unsupported attribute.
+ */
 class Order extends Exception
 {
     protected ?string $attribute;
+
+    /**
+     * @param string $message The exception message
+     * @param int|string $code The exception code
+     * @param Throwable|null $previous The previous throwable for chaining
+     * @param string|null $attribute The attribute that caused the ordering error
+     */
     public function __construct(string $message, int|string $code = 0, ?Throwable $previous = null, ?string $attribute = null)
     {
         $this->attribute = $attribute;
         parent::__construct($message, $code, $previous);
     }
+
+    /**
+     * Get the attribute that caused the ordering error.
+     *
+     * @return string|null
+     */
     public function getAttribute(): ?string
     {
         return $this->attribute;
diff --git a/src/Database/Exception/Query.php b/src/Database/Exception/Query.php
index 58f699d12a..ba1ebcfef0 100644
--- a/src/Database/Exception/Query.php
+++ b/src/Database/Exception/Query.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a query is malformed or contains invalid parameters.
+ */
 class Query extends Exception
 {
 }
diff --git a/src/Database/Exception/Relationship.php b/src/Database/Exception/Relationship.php
index bcb296579c..ff831e50a4 100644
--- a/src/Database/Exception/Relationship.php
+++ b/src/Database/Exception/Relationship.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a relationship operation fails or a relationship constraint is violated.
+ */
 class Relationship extends Exception
 {
 }
diff --git a/src/Database/Exception/Restricted.php b/src/Database/Exception/Restricted.php
index 1ef9fefd72..b6c23d127e 100644
--- a/src/Database/Exception/Restricted.php
+++ b/src/Database/Exception/Restricted.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when an operation is restricted due to a relationship constraint (e.g. restrict on delete).
+ */
 class Restricted extends Exception
 {
 }
diff --git a/src/Database/Exception/Structure.php b/src/Database/Exception/Structure.php
index 26e9ce1fdb..47901cf2ae 100644
--- a/src/Database/Exception/Structure.php
+++ b/src/Database/Exception/Structure.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a document does not conform to its collection's structure requirements.
+ */
 class Structure extends Exception
 {
 }
diff --git a/src/Database/Exception/Timeout.php b/src/Database/Exception/Timeout.php
index 613e74e55d..3079baa53c 100644
--- a/src/Database/Exception/Timeout.php
+++ b/src/Database/Exception/Timeout.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database operation exceeds the configured timeout duration.
+ */
 class Timeout extends Exception
 {
 }
diff --git a/src/Database/Exception/Transaction.php b/src/Database/Exception/Transaction.php
index 3a3ddf0afa..2abe9ebfb5 100644
--- a/src/Database/Exception/Transaction.php
+++ b/src/Database/Exception/Transaction.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a database transaction fails to begin, commit, or rollback.
+ */
 class Transaction extends Exception
 {
 }
diff --git a/src/Database/Exception/Truncate.php b/src/Database/Exception/Truncate.php
index 9bd0ffb129..d567876f7c 100644
--- a/src/Database/Exception/Truncate.php
+++ b/src/Database/Exception/Truncate.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a value exceeds the maximum allowed length and would be truncated.
+ */
 class Truncate extends Exception
 {
 }
diff --git a/src/Database/Exception/Type.php b/src/Database/Exception/Type.php
index 045ec5af9e..28226a3a25 100644
--- a/src/Database/Exception/Type.php
+++ b/src/Database/Exception/Type.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Exception;
 
+/**
+ * Thrown when a value has an incompatible or unsupported type for the target attribute.
+ */
 class Type extends Exception
 {
 }
diff --git a/src/Database/Exception/Unique.php b/src/Database/Exception/Unique.php
index d8e2fe5014..b192f80e46 100644
--- a/src/Database/Exception/Unique.php
+++ b/src/Database/Exception/Unique.php
@@ -2,6 +2,16 @@
 
 namespace Utopia\Database\Exception;
 
+use Throwable;
+
 class Unique extends Duplicate
 {
+    public function __construct(string $message, int|string $code = 0, ?Throwable $previous = null)
+    {
+        if ($message === 'Unique index violation') {
+            $message = 'Document with the requested unique attributes already exists';
+        }
+
+        parent::__construct($message, $code, $previous);
+    }
 }
diff --git a/src/Database/Helpers/ID.php b/src/Database/Helpers/ID.php
index 3a690a7b1d..90a406ebd5 100644
--- a/src/Database/Helpers/ID.php
+++ b/src/Database/Helpers/ID.php
@@ -2,14 +2,20 @@
 
 namespace Utopia\Database\Helpers;
 
+use Exception;
 use Utopia\Database\Exception as DatabaseException;
 
+/**
+ * Helper class for generating and creating document identifiers.
+ */
 class ID
 {
     /**
-     * Create a new unique ID
+     * Create a new unique ID using uniqid with optional random padding.
      *
-     * @throws DatabaseException
+     * @param int $padding Number of random hex characters to append for uniqueness
+     * @return string The generated unique identifier
+     * @throws DatabaseException If random bytes generation fails
      */
     public static function unique(int $padding = 7): string
     {
@@ -17,8 +23,8 @@ public static function unique(int $padding = 7): string
 
         if ($padding > 0) {
             try {
-                $bytes = \random_bytes(\max(1, (int)\ceil(($padding / 2)))); // one byte expands to two chars
-            } catch (\Exception $e) {
+                $bytes = \random_bytes(\max(1, (int) \ceil(($padding / 2)))); // one byte expands to two chars
+            } catch (Exception $e) {
                 throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
             }
 
@@ -29,7 +35,10 @@ public static function unique(int $padding = 7): string
     }
 
     /**
-     * Create a new ID from a string
+     * Create an ID from a custom string value.
+     *
+     * @param string $id The custom identifier string
+     * @return string The provided identifier
      */
     public static function custom(string $id): string
     {
diff --git a/src/Database/Helpers/Permission.php b/src/Database/Helpers/Permission.php
index 18c4fe5a94..962065be5c 100644
--- a/src/Database/Helpers/Permission.php
+++ b/src/Database/Helpers/Permission.php
@@ -3,9 +3,12 @@
 namespace Utopia\Database\Helpers;
 
 use Exception;
-use Utopia\Database\Database;
 use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\PermissionType;
 
+/**
+ * Represents a database permission binding a permission type to a role.
+ */
 class Permission
 {
     private Role $role;
@@ -15,12 +18,18 @@ class Permission
      */
     private static array $aggregates = [
         'write' => [
-            Database::PERMISSION_CREATE,
-            Database::PERMISSION_UPDATE,
-            Database::PERMISSION_DELETE,
-        ]
+            PermissionType::Create->value,
+            PermissionType::Update->value,
+            PermissionType::Delete->value,
+        ],
     ];
 
+    /**
+     * @param string $permission The permission type (e.g. read, create, update, delete, write)
+     * @param string $role The role name
+     * @param string $identifier The role identifier
+     * @param string $dimension The role dimension
+     */
     public function __construct(
         private string $permission,
         string $role,
@@ -31,16 +40,17 @@ public function __construct(
     }
 
     /**
-     * Create a permission string from this Permission instance
+     * Create a permission string from this Permission instance.
      *
-     * @return string
+     * @return string The formatted permission string (e.g. 'read("user:123")')
      */
     public function toString(): string
     {
-        return $this->permission . '("' . $this->role->toString() . '")';
+        return $this->permission.'("'.$this->role->toString().'")';
     }
 
     /**
+     * Get the permission type string.
      *
      * @return string
      */
@@ -50,6 +60,8 @@ public function getPermission(): string
     }
 
     /**
+     * Get the role name associated with this permission.
+     *
      * @return string
      */
     public function getRole(): string
@@ -58,6 +70,8 @@ public function getRole(): string
     }
 
     /**
+     * Get the role identifier associated with this permission.
+     *
      * @return string
      */
     public function getIdentifier(): string
@@ -66,6 +80,8 @@ public function getIdentifier(): string
     }
 
     /**
+     * Get the role dimension associated with this permission.
+     *
      * @return string
      */
     public function getDimension(): string
@@ -74,24 +90,24 @@ public function getDimension(): string
     }
 
     /**
-     * Parse a permission string into a Permission object
+     * Parse a permission string into a Permission object.
      *
-     * @param string $permission
+     * @param string $permission The permission string to parse (e.g. 'read("user:123")')
      * @return self
-     * @throws Exception
+     * @throws DatabaseException If the permission string format or type is invalid
      */
     public static function parse(string $permission): self
     {
         $permissionParts = \explode('("', $permission);
 
         if (\count($permissionParts) !== 2) {
-            throw new DatabaseException('Invalid permission string format: "' . $permission . '".');
+            throw new DatabaseException('Invalid permission string format: "'.$permission.'".');
         }
 
         $permission = $permissionParts[0];
 
-        if (!\in_array($permission, array_merge(Database::PERMISSIONS, [Database::PERMISSION_WRITE]))) {
-            throw new DatabaseException('Invalid permission type: "' . $permission . '".');
+        if (! \in_array($permission, array_column(PermissionType::cases(), 'value'))) {
+            throw new DatabaseException('Invalid permission type: "'.$permission.'".');
         }
         $fullRole = \str_replace('")', '', $permissionParts[1]);
         $roleParts = \explode(':', $fullRole);
@@ -100,16 +116,17 @@ public static function parse(string $permission): self
         $hasIdentifier = \count($roleParts) > 1;
         $hasDimension = \str_contains($fullRole, '/');
 
-        if (!$hasIdentifier && !$hasDimension) {
+        if (! $hasIdentifier && ! $hasDimension) {
             return new self($permission, $role);
         }
 
-        if ($hasIdentifier && !$hasDimension) {
+        if ($hasIdentifier && ! $hasDimension) {
             $identifier = $roleParts[1];
+
             return new self($permission, $role, $identifier);
         }
 
-        if (!$hasIdentifier) {
+        if (! $hasIdentifier) {
             $dimensionParts = \explode('/', $fullRole);
             if (\count($dimensionParts) !== 2) {
                 throw new DatabaseException('Only one dimension can be provided');
@@ -121,6 +138,7 @@ public static function parse(string $permission): self
             if (empty($dimension)) {
                 throw new DatabaseException('Dimension must not be empty');
             }
+
             return new self($permission, $role, '', $dimension);
         }
 
@@ -143,26 +161,36 @@ public static function parse(string $permission): self
     /**
      * Map aggregate permissions into the set of individual permissions they represent.
      *
-     * @param array<string>|null $permissions
-     * @param array<string> $allowed
+     * @param  array<string>|null  $permissions
+     * @param  array<string>  $allowed
      * @return array<string>|null
+     *
      * @throws Exception
      */
-    public static function aggregate(?array $permissions, array $allowed = Database::PERMISSIONS): ?array
+    /**
+     * @param  array<string>|null  $permissions
+     * @param  array<PermissionType>  $allowed
+     * @return array<string>|null
+     *
+     * @throws Exception
+     */
+    public static function aggregate(?array $permissions, array $allowed = [PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete]): ?array
     {
         if (\is_null($permissions)) {
             return null;
         }
+        $allowedValues = \array_map(fn (PermissionType $p) => $p->value, $allowed);
         $mutated = [];
         foreach ($permissions as $i => $permission) {
             $permission = self::parse($permission);
             foreach (self::$aggregates as $type => $subTypes) {
                 if ($permission->getPermission() != $type) {
                     $mutated[] = $permission->toString();
+
                     continue;
                 }
                 foreach ($subTypes as $subType) {
-                    if (!\in_array($subType, $allowed)) {
+                    if (! \in_array($subType, $allowedValues)) {
                         continue;
                     }
                     $mutated[] = (new self(
@@ -174,14 +202,15 @@ public static function aggregate(?array $permissions, array $allowed = Database:
                 }
             }
         }
+
         return \array_values(\array_unique($mutated));
     }
 
     /**
-     * Create a read permission string from the given Role
+     * Create a read permission string from the given Role.
      *
-     * @param Role $role
-     * @return string
+     * @param Role $role The role to grant read permission to
+     * @return string The formatted permission string
      */
     public static function read(Role $role): string
     {
@@ -191,14 +220,15 @@ public static function read(Role $role): string
             $role->getIdentifier(),
             $role->getDimension()
         );
+
         return $permission->toString();
     }
 
     /**
-     * Create a create permission string from the given Role
+     * Create a create permission string from the given Role.
      *
-     * @param Role $role
-     * @return string
+     * @param Role $role The role to grant create permission to
+     * @return string The formatted permission string
      */
     public static function create(Role $role): string
     {
@@ -208,14 +238,15 @@ public static function create(Role $role): string
             $role->getIdentifier(),
             $role->getDimension()
         );
+
         return $permission->toString();
     }
 
     /**
-     * Create an update permission string from the given Role
+     * Create an update permission string from the given Role.
      *
-     * @param Role $role
-     * @return string
+     * @param Role $role The role to grant update permission to
+     * @return string The formatted permission string
      */
     public static function update(Role $role): string
     {
@@ -225,14 +256,15 @@ public static function update(Role $role): string
             $role->getIdentifier(),
             $role->getDimension()
         );
+
         return $permission->toString();
     }
 
     /**
-     * Create a delete permission string from the given Role
+     * Create a delete permission string from the given Role.
      *
-     * @param Role $role
-     * @return string
+     * @param Role $role The role to grant delete permission to
+     * @return string The formatted permission string
      */
     public static function delete(Role $role): string
     {
@@ -242,14 +274,15 @@ public static function delete(Role $role): string
             $role->getIdentifier(),
             $role->getDimension()
         );
+
         return $permission->toString();
     }
 
     /**
-     * Create a write permission string from the given Role
+     * Create a write permission string from the given Role.
      *
-     * @param Role $role
-     * @return string
+     * @param Role $role The role to grant write permission to
+     * @return string The formatted permission string
      */
     public static function write(Role $role): string
     {
@@ -259,6 +292,7 @@ public static function write(Role $role): string
             $role->getIdentifier(),
             $role->getDimension()
         );
+
         return $permission->toString();
     }
 }
diff --git a/src/Database/Helpers/Role.php b/src/Database/Helpers/Role.php
index 1682cb5471..951271443e 100644
--- a/src/Database/Helpers/Role.php
+++ b/src/Database/Helpers/Role.php
@@ -2,8 +2,18 @@
 
 namespace Utopia\Database\Helpers;
 
+use Exception;
+
+/**
+ * Represents a role used for permission checks, consisting of a role type, identifier, and dimension.
+ */
 class Role
 {
+    /**
+     * @param string $role The role type (e.g. user, users, team, any, guests, member, label)
+     * @param string $identifier The role identifier (e.g. user ID, team ID)
+     * @param string $dimension The role dimension (e.g. user status, team role)
+     */
     public function __construct(
         private string $role,
         private string $identifier = '',
@@ -12,23 +22,26 @@ public function __construct(
     }
 
     /**
-     * Create a role string from this Role instance
+     * Create a role string from this Role instance.
      *
-     * @return string
+     * @return string The formatted role string (e.g. 'user:123/verified')
      */
     public function toString(): string
     {
         $str = $this->role;
         if ($this->identifier) {
-            $str .= ':' . $this->identifier;
+            $str .= ':'.$this->identifier;
         }
         if ($this->dimension) {
-            $str .= '/' . $this->dimension;
+            $str .= '/'.$this->dimension;
         }
+
         return $str;
     }
 
     /**
+     * Get the role type.
+     *
      * @return string
      */
     public function getRole(): string
@@ -37,6 +50,8 @@ public function getRole(): string
     }
 
     /**
+     * Get the role identifier.
+     *
      * @return string
      */
     public function getIdentifier(): string
@@ -45,6 +60,8 @@ public function getIdentifier(): string
     }
 
     /**
+     * Get the role dimension.
+     *
      * @return string
      */
     public function getDimension(): string
@@ -53,11 +70,11 @@ public function getDimension(): string
     }
 
     /**
-     * Parse a role string into a Role object
+     * Parse a role string into a Role object.
      *
-     * @param string $role
+     * @param string $role The role string to parse (e.g. 'user:123/verified')
      * @return self
-     * @throws \Exception
+     * @throws Exception If the dimension format is invalid
      */
     public static function parse(string $role): self
     {
@@ -66,51 +83,54 @@ public static function parse(string $role): self
         $hasDimension = \str_contains($role, '/');
         $role = $roleParts[0];
 
-        if (!$hasIdentifier && !$hasDimension) {
+        if (! $hasIdentifier && ! $hasDimension) {
             return new self($role);
         }
 
-        if ($hasIdentifier && !$hasDimension) {
+        if ($hasIdentifier && ! $hasDimension) {
             $identifier = $roleParts[1];
+
             return new self($role, $identifier);
         }
 
-        if (!$hasIdentifier) {
+        if (! $hasIdentifier) {
             $dimensionParts = \explode('/', $role);
             if (\count($dimensionParts) !== 2) {
-                throw new \Exception('Only one dimension can be provided');
+                throw new Exception('Only one dimension can be provided');
             }
 
             $role = $dimensionParts[0];
             $dimension = $dimensionParts[1];
 
             if (empty($dimension)) {
-                throw new \Exception('Dimension must not be empty');
+                throw new Exception('Dimension must not be empty');
             }
+
             return new self($role, '', $dimension);
         }
 
         // Has both identifier and dimension
         $dimensionParts = \explode('/', $roleParts[1]);
         if (\count($dimensionParts) !== 2) {
-            throw new \Exception('Only one dimension can be provided');
+            throw new Exception('Only one dimension can be provided');
         }
 
         $identifier = $dimensionParts[0];
         $dimension = $dimensionParts[1];
 
         if (empty($dimension)) {
-            throw new \Exception('Dimension must not be empty');
+            throw new Exception('Dimension must not be empty');
         }
+
         return new self($role, $identifier, $dimension);
     }
 
     /**
-     * Create a user role from the given ID
+     * Create a user role from the given ID.
      *
-     * @param string $identifier
-     * @param string $status
-     * @return self
+     * @param string $identifier The user ID
+     * @param string $status The user status dimension (e.g. 'verified')
+     * @return Role
      */
     public static function user(string $identifier, string $status = ''): Role
     {
@@ -118,9 +138,9 @@ public static function user(string $identifier, string $status = ''): Role
     }
 
     /**
-     * Create a users role
+     * Create a users role representing all authenticated users.
      *
-     * @param string $status
+     * @param string $status The user status dimension (e.g. 'verified')
      * @return self
      */
     public static function users(string $status = ''): self
@@ -129,10 +149,10 @@ public static function users(string $status = ''): self
     }
 
     /**
-     * Create a team role from the given ID and dimension
+     * Create a team role from the given ID and dimension.
      *
-     * @param string $identifier
-     * @param string $dimension
+     * @param string $identifier The team ID
+     * @param string $dimension The team role dimension (e.g. 'admin', 'member')
      * @return self
      */
     public static function team(string $identifier, string $dimension = ''): self
@@ -141,9 +161,9 @@ public static function team(string $identifier, string $dimension = ''): self
     }
 
     /**
-     * Create a label role from the given ID
+     * Create a label role from the given identifier.
      *
-     * @param string $identifier
+     * @param string $identifier The label identifier
      * @return self
      */
     public static function label(string $identifier): self
@@ -152,9 +172,9 @@ public static function label(string $identifier): self
     }
 
     /**
-     * Create an any satisfy role
+     * Create a role that matches any user, authenticated or not.
      *
-     * @return self
+     * @return Role
      */
     public static function any(): Role
     {
@@ -162,7 +182,7 @@ public static function any(): Role
     }
 
     /**
-     * Create a guests role
+     * Create a role representing unauthenticated guest users.
      *
      * @return self
      */
@@ -171,6 +191,12 @@ public static function guests(): self
         return new self('guests');
     }
 
+    /**
+     * Create a member role from the given identifier.
+     *
+     * @param string $identifier The member ID
+     * @return self
+     */
     public static function member(string $identifier): self
     {
         return new self('member', $identifier);
diff --git a/src/Database/Hook/AllowNullColumn.php b/src/Database/Hook/AllowNullColumn.php
new file mode 100644
index 0000000000..f5be7d71db
--- /dev/null
+++ b/src/Database/Hook/AllowNullColumn.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use InvalidArgumentException;
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Hook\Filter;
+
+final readonly class AllowNullColumn implements Filter
+{
+    private const IDENTIFIER_PATTERN = '/^[a-zA-Z_][a-zA-Z0-9_.\-]*$/';
+
+    public function __construct(
+        private Filter $filter,
+        private string $column,
+        private string $quoteChar = '`',
+    ) {
+        if (! \preg_match(self::IDENTIFIER_PATTERN, $column)) {
+            throw new InvalidArgumentException('Invalid column name: '.$column);
+        }
+    }
+
+    public function filter(string $table): Condition
+    {
+        return self::wrap($this->filter->filter($table), $this->column, $this->quoteChar);
+    }
+
+    public static function wrap(Condition $condition, string $column, string $quoteChar = '`'): Condition
+    {
+        if (! \preg_match(self::IDENTIFIER_PATTERN, $column)) {
+            throw new InvalidArgumentException('Invalid column name: '.$column);
+        }
+
+        return new Condition(
+            '('.$condition->expression.' OR '.self::quote($column, $quoteChar).' IS NULL)',
+            $condition->bindings,
+        );
+    }
+
+    public static function quote(string $identifier, string $quoteChar = '`'): string
+    {
+        $parts = \explode('.', $identifier);
+        $quoted = \array_map(
+            fn (string $part): string => $quoteChar.\str_replace($quoteChar, $quoteChar.$quoteChar, $part).$quoteChar,
+            $parts,
+        );
+
+        return \implode('.', $quoted);
+    }
+}
diff --git a/src/Database/Hook/Decorator.php b/src/Database/Hook/Decorator.php
new file mode 100644
index 0000000000..5b19b437bf
--- /dev/null
+++ b/src/Database/Hook/Decorator.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Query\Hook;
+
+/**
+ * Hook for transforming documents after they are read from or written to the database.
+ *
+ * Decorators run inline in the document pipeline: they receive a document, modify it,
+ * and return it. The returned document is what the caller receives. This makes them
+ * suitable for adding metadata, transforming attributes, or counting operations.
+ *
+ * Decorators differ from {@see Lifecycle} hooks in two key ways:
+ *
+ * 1. **Return value**: Decorators return the (possibly modified) Document back into the
+ *    pipeline. Lifecycle hooks return void and cannot influence the result.
+ *
+ * 2. **Error handling**: Decorator exceptions propagate to the caller and abort the
+ *    operation. Lifecycle hook exceptions are silently caught so side effects never
+ *    break business logic.
+ *
+ * Decorators also receive the collection Document as context, which Lifecycle hooks
+ * do not. Use Lifecycle hooks for fire-and-forget side effects (auditing, logging,
+ * event dispatch). Use Decorators when you need to modify the document before it
+ * reaches the caller.
+ *
+ * Runs after: relationship population, casting, decoding, type mapping.
+ * Runs before: lifecycle event triggers.
+ */
+interface Decorator extends Hook
+{
+    /**
+     * Decorate a document after a database operation.
+     *
+     * @param  Event  $event  The operation that produced this document
+     * @param  Document  $collection  The collection the document belongs to
+     * @param  Document  $document  The document to decorate
+     * @return Document The decorated document
+     */
+    public function decorate(Event $event, Document $collection, Document $document): Document;
+}
diff --git a/src/Database/Hook/Interceptor.php b/src/Database/Hook/Interceptor.php
new file mode 100644
index 0000000000..18ac1b9418
--- /dev/null
+++ b/src/Database/Hook/Interceptor.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Document;
+
+/**
+ * Base class for database write hooks with default no-op implementations.
+ *
+ * Provides empty defaults for all query-level and document-level write methods.
+ * Subclasses override only the methods they need, avoiding boilerplate stubs.
+ *
+ * Query-level methods (afterCreate, afterUpdate, afterBatchUpdate, afterDelete)
+ * exist because the database Write interface extends the query-layer Write
+ * interface. Most database hooks only need the document-level methods.
+ */
+abstract class Interceptor implements Write
+{
+    public function decorateRow(array $row, array $metadata = []): array
+    {
+        return $row;
+    }
+
+    public function afterCreate(string $table, array $metadata, mixed $context): void
+    {
+    }
+
+    public function afterUpdate(string $table, array $metadata, mixed $context): void
+    {
+    }
+
+    public function afterBatchUpdate(string $table, array $updateData, array $metadata, mixed $context): void
+    {
+    }
+
+    public function afterDelete(string $table, array $ids, mixed $context): void
+    {
+    }
+
+    public function afterDocumentCreate(string $collection, array $documents, WriteContext $context): void
+    {
+    }
+
+    public function afterDocumentUpdate(string $collection, Document $document, bool $skipPermissions, WriteContext $context): void
+    {
+    }
+
+    public function afterDocumentBatchUpdate(string $collection, Document $updates, array $documents, WriteContext $context): void
+    {
+    }
+
+    public function afterDocumentUpsert(string $collection, array $changes, WriteContext $context): void
+    {
+    }
+
+    public function afterDocumentDelete(string $collection, array $documentIds, WriteContext $context): void
+    {
+    }
+}
diff --git a/src/Database/Hook/Lifecycle.php b/src/Database/Hook/Lifecycle.php
new file mode 100644
index 0000000000..45d13115e2
--- /dev/null
+++ b/src/Database/Hook/Lifecycle.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Event;
+use Utopia\Query\Hook;
+
+/**
+ * Lifecycle hook for fire-and-forget side effects on database events.
+ *
+ * Implementations receive lifecycle events (document CRUD, collection changes, etc.)
+ * and can respond with side effects (auditing, logging, analytics, event dispatch).
+ *
+ * Lifecycle hooks differ from {@see Decorator} hooks in two key ways:
+ *
+ * 1. **Return value**: Lifecycle hooks return void and cannot modify the document or
+ *    influence the operation result. Decorators return a Document back into the pipeline.
+ *
+ * 2. **Error handling**: Exceptions thrown by lifecycle hooks are silently caught to
+ *    prevent side effects from breaking business logic. Decorator exceptions propagate
+ *    to the caller.
+ *
+ * Lifecycle hooks do not receive collection context. Use Decorators when you need to
+ * transform documents before they reach the caller.
+ */
+interface Lifecycle extends Hook
+{
+    /**
+     * Handle a lifecycle event.
+     *
+     * @param  Event  $event  The event type
+     * @param  mixed  $data  The event payload (Document, array, string, int, etc.)
+     */
+    public function handle(Event $event, mixed $data): void;
+}
diff --git a/src/Database/Hook/Mongo/PermissionFilter.php b/src/Database/Hook/Mongo/PermissionFilter.php
new file mode 100644
index 0000000000..7666a25458
--- /dev/null
+++ b/src/Database/Hook/Mongo/PermissionFilter.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Utopia\Database\Hook\Mongo;
+
+use Utopia\Database\Database;
+use Utopia\Database\Hook\Read;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+
+/**
+ * MongoDB read hook that injects permission-based filters into queries.
+ *
+ * Unlike SQL adapters which use separate PermissionFilter (read) and Permission (write)
+ * hooks, MongoDB stores permissions as an embedded `_permissions` array directly on the
+ * document. This means no side-table management is needed on write, so there is no
+ * corresponding MongoPermission hook. Read filtering is sufficient because the
+ * permissions are part of the document itself.
+ */
+class PermissionFilter implements Read
+{
+    /**
+     * @param Authorization $authorization The authorization instance providing current user roles
+     */
+    public function __construct(
+        private Authorization $authorization,
+    ) {
+    }
+
+    /**
+     * Inject an exact-match `$in` filter of `type("role")` strings against `_permissions`.
+     *
+     * @param array<string, mixed> $filters The current MongoDB filter array
+     * @param string $collection The collection being queried
+     * @param string $forPermission The permission type to filter for (e.g. 'read')
+     * @return array<string, mixed> The modified filter array with permission constraints
+     */
+    public function applyFilters(array $filters, string $collection, string $forPermission = 'read'): array
+    {
+        if (! $this->authorization->getStatus()) {
+            return $filters;
+        }
+
+        if ($collection === Database::METADATA) {
+            return $filters;
+        }
+
+        $permissions = [];
+        foreach ($this->authorization->getRoles() as $role) {
+            $permissions[] = $forPermission.'("'.$role.'")';
+        }
+
+        /** @var array<string, mixed> $permissionsFilter */
+        $permissionsFilter = isset($filters[Storage::PERMISSIONS]) && \is_array($filters[Storage::PERMISSIONS])
+            ? $filters[Storage::PERMISSIONS]
+            : [];
+        $permissionsFilter['$in'] = $permissions;
+        $filters[Storage::PERMISSIONS] = $permissionsFilter;
+
+        return $filters;
+    }
+}
diff --git a/src/Database/Hook/Mongo/TenantFilter.php b/src/Database/Hook/Mongo/TenantFilter.php
new file mode 100644
index 0000000000..3a98438f69
--- /dev/null
+++ b/src/Database/Hook/Mongo/TenantFilter.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Utopia\Database\Hook\Mongo;
+
+use Closure;
+use Utopia\Database\Hook\Read;
+use Utopia\Database\Storage;
+
+/**
+ * MongoDB read hook that injects tenant isolation filters into queries for shared-table configurations.
+ *
+ * Unlike SQL adapters which use separate TenantFilter (read) and Tenant (write) hooks,
+ * MongoDB stores the tenant identifier as an embedded `_tenant` field directly on the document.
+ * The Mongo adapter sets this field during document creation without a separate write hook.
+ * Read filtering is sufficient because tenant isolation only requires query-time filtering.
+ */
+class TenantFilter implements Read
+{
+    /**
+     * @param int|string|null $tenant The current tenant ID
+     * @param bool $sharedTables Whether shared tables mode is enabled
+     * @param Closure(string, array<int|string>=): (int|string|null|array<string, array<int|string|null>>) $getTenantFilters Closure that returns tenant filter values for a collection
+     */
+    public function __construct(
+        private int|string|null $tenant,
+        private bool $sharedTables,
+        private Closure $getTenantFilters,
+    ) {
+    }
+
+    /**
+     * Add a _tenant filter to restrict results to the current tenant.
+     *
+     * @param array<string, mixed> $filters The current MongoDB filter array
+     * @param string $collection The collection being queried
+     * @param string $forPermission The permission type (unused in tenant filtering)
+     * @return array<string, mixed> The modified filter array with tenant constraints
+     */
+    public function applyFilters(array $filters, string $collection, string $forPermission = 'read'): array
+    {
+        if (! $this->sharedTables || $this->tenant === null) {
+            return $filters;
+        }
+
+        $filters[Storage::TENANT] = ($this->getTenantFilters)($collection);
+
+        return $filters;
+    }
+}
diff --git a/src/Database/Hook/PermissionAllowNullUid.php b/src/Database/Hook/PermissionAllowNullUid.php
new file mode 100644
index 0000000000..464f7d46f7
--- /dev/null
+++ b/src/Database/Hook/PermissionAllowNullUid.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Hook\Filter;
+
+final readonly class PermissionAllowNullUid implements Filter
+{
+    private AllowNullColumn $inner;
+
+    public function __construct(
+        Filter $filter,
+        string $documentColumn,
+        string $quoteChar = '`',
+    ) {
+        $this->inner = new AllowNullColumn($filter, $documentColumn, $quoteChar);
+    }
+
+    public function filter(string $table): Condition
+    {
+        return $this->inner->filter($table);
+    }
+}
diff --git a/src/Database/Hook/PermissionFilter.php b/src/Database/Hook/PermissionFilter.php
new file mode 100644
index 0000000000..e3bc93af21
--- /dev/null
+++ b/src/Database/Hook/PermissionFilter.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Closure;
+use InvalidArgumentException;
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Builder\JoinType;
+use Utopia\Query\Hook\Filter;
+use Utopia\Query\Hook\Join\Condition as JoinCondition;
+use Utopia\Query\Hook\Join\Filter as JoinFilter;
+
+/**
+ * SQL read hook that generates permission-checking subquery conditions for document access control.
+ *
+ * Produces an EXISTS/IN subquery against a permissions side table, filtering documents
+ * by the current user's roles, permission type, and optionally specific columns.
+ */
+class PermissionFilter implements Filter, JoinFilter
+{
+    private const IDENTIFIER_PATTERN = '/^[a-zA-Z_][a-zA-Z0-9_.\-]*$/';
+
+    /**
+     * @param  list<string>  $roles
+     * @param  Closure(string): string  $permissionsTable  Receives the base table name, returns the permissions table name
+     * @param  list<string>|null  $columns  Column names to check permissions for. NULL rows (wildcard) are always included.
+     * @param  Filter|null  $subqueryFilter  Optional filter applied inside the permissions subquery (e.g. tenant filtering)
+     */
+    public function __construct(
+        protected array $roles,
+        protected Closure $permissionsTable,
+        protected string $type = 'read',
+        protected ?array $columns = null,
+        protected string $documentColumn = 'id',
+        protected string $permDocumentColumn = 'document_id',
+        protected string $permRoleColumn = 'role',
+        protected string $permTypeColumn = 'type',
+        protected string $permColumnColumn = 'column',
+        protected ?Filter $subqueryFilter = null,
+        protected string $quoteChar = '`',
+    ) {
+        foreach ([$documentColumn, $permDocumentColumn, $permRoleColumn, $permTypeColumn, $permColumnColumn] as $col) {
+            if (! \preg_match(self::IDENTIFIER_PATTERN, $col)) {
+                throw new InvalidArgumentException('Invalid column name: '.$col);
+            }
+        }
+    }
+
+    /**
+     * Generate a SQL condition that filters documents by permission role membership.
+     *
+     * @param string $table The base table name being queried
+     * @return Condition A condition with an IN subquery against the permissions table
+     * @throws InvalidArgumentException If the permissions table name is invalid
+     */
+    public function filter(string $table): Condition
+    {
+        if (empty($this->roles)) {
+            return new Condition('1 = 0');
+        }
+
+        /** @var string $permTable */
+        $permTable = ($this->permissionsTable)($table);
+
+        if (! \preg_match(self::IDENTIFIER_PATTERN, $permTable)) {
+            throw new InvalidArgumentException('Invalid permissions table name: '.$permTable);
+        }
+
+        $quotedPermTable = $this->quoteTableIdentifier($permTable);
+
+        $rolePlaceholders = \implode(', ', \array_fill(0, \count($this->roles), '?'));
+
+        $columnClause = '';
+        $columnBindings = [];
+
+        if ($this->columns !== null) {
+            if (empty($this->columns)) {
+                $columnClause = " AND {$this->permColumnColumn} IS NULL";
+            } else {
+                $colPlaceholders = \implode(', ', \array_fill(0, \count($this->columns), '?'));
+                $columnClause = " AND ({$this->permColumnColumn} IS NULL OR {$this->permColumnColumn} IN ({$colPlaceholders}))";
+                $columnBindings = $this->columns;
+            }
+        }
+
+        $subFilterClause = '';
+        $subFilterBindings = [];
+        if ($this->subqueryFilter !== null) {
+            $subCondition = $this->subqueryFilter->filter($permTable);
+            $subFilterClause = ' AND '.$subCondition->expression;
+            $subFilterBindings = $subCondition->bindings;
+        }
+
+        return new Condition(
+            "{$this->documentColumn} IN (SELECT DISTINCT {$this->permDocumentColumn} FROM {$quotedPermTable} WHERE {$this->permRoleColumn} IN ({$rolePlaceholders}) AND {$this->permTypeColumn} = ?{$columnClause}{$subFilterClause})",
+            [...$this->roles, $this->type, ...$columnBindings, ...$subFilterBindings],
+        );
+    }
+
+    /**
+     * Per-join-table permission checks are applied via separate PermissionFilter hooks
+     * registered by the SQL adapter for each joined table. This hook only handles the
+     * primary table's WHERE clause, so filterJoin returns null.
+     */
+    public function filterJoin(string $table, JoinType $joinType): ?JoinCondition
+    {
+        return null;
+    }
+
+    private function quoteTableIdentifier(string $table): string
+    {
+        $q = $this->quoteChar;
+        $parts = \explode('.', $table);
+        $quoted = \array_map(fn (string $part): string => $q.\str_replace($q, $q.$q, $part).$q, $parts);
+
+        return \implode('.', $quoted);
+    }
+}
diff --git a/src/Database/Hook/PermissionJoinFilter.php b/src/Database/Hook/PermissionJoinFilter.php
new file mode 100644
index 0000000000..4cf1006ea4
--- /dev/null
+++ b/src/Database/Hook/PermissionJoinFilter.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\JoinType;
+use Utopia\Query\Hook\Join\Condition as JoinCondition;
+use Utopia\Query\Hook\Join\Filter as JoinFilter;
+use Utopia\Query\Hook\Join\Placement;
+
+/**
+ * Permission check bound to one join alias.
+ *
+ * Left joins place the check in ON so a failed ACL nulls the join side and
+ * keeps the main row. Right, full-outer, inner, and cross joins place it in
+ * WHERE so unauthorized join rows are dropped. Full outer keeps unmatched
+ * primary rows with `acl OR alias._uid IS NULL`.
+ */
+final class PermissionJoinFilter implements JoinFilter
+{
+    public function __construct(
+        private readonly PermissionFilter $filter,
+        private readonly string $alias,
+        private readonly string $quoteChar = '`',
+    ) {
+    }
+
+    public function filterJoin(string $table, JoinType $joinType): ?JoinCondition
+    {
+        if ($table !== $this->alias) {
+            return null;
+        }
+
+        $condition = $this->filter->filter($table);
+        if ($joinType === JoinType::FullOuter) {
+            $condition = AllowNullColumn::wrap(
+                $condition,
+                $this->alias.'.'.Storage::UID,
+                $this->quoteChar,
+            );
+        }
+
+        return new JoinCondition(
+            $condition,
+            match ($joinType) {
+                JoinType::Left => Placement::On,
+                default => Placement::Where,
+            },
+        );
+    }
+}
diff --git a/src/Database/Hook/Permissions.php b/src/Database/Hook/Permissions.php
new file mode 100644
index 0000000000..9ac946a542
--- /dev/null
+++ b/src/Database/Hook/Permissions.php
@@ -0,0 +1,553 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\Feature\InsertOrIgnore as InsertOrIgnoreFeature;
+use Utopia\Query\Query;
+
+/**
+ * Permission hook that handles both read-side query filtering and write-side side-table management.
+ *
+ * On reads: The SQL adapter generates permission-checking subquery conditions when this hook is registered.
+ * On writes: Manages inserting, updating, and deleting permission entries in the _perms side table.
+ */
+class Permissions extends Interceptor
+{
+    private const PERM_TYPES = [
+        PermissionType::Create,
+        PermissionType::Read,
+        PermissionType::Update,
+        PermissionType::Delete,
+    ];
+
+    /**
+     * Insert permission rows for all newly created documents.
+     *
+     * @param string $collection The collection name
+     * @param array<Document> $documents The created documents
+     * @param WriteContext $context The write context providing builder and execution closures
+     */
+    public function afterDocumentCreate(string $collection, array $documents, WriteContext $context): void
+    {
+        $permBuilder = ($context->createBuilder)()->into(($context->getTableRaw)(Storage::permissionsTable($collection)));
+        $hasPermissions = false;
+
+        foreach ($documents as $document) {
+            foreach ($this->buildPermissionRows($document, $context) as $row) {
+                $permBuilder->set($row);
+                $hasPermissions = true;
+            }
+        }
+
+        if ($hasPermissions) {
+            if ($context->skipDuplicates) {
+                if (! $permBuilder instanceof InsertOrIgnoreFeature) {
+                    throw new DatabaseException('Insert-or-ignore is not supported on this dialect');
+                }
+
+                $result = $permBuilder->insertOrIgnore();
+            } else {
+                $result = $permBuilder->insert();
+            }
+            $stmt = ($context->executeResult)($result, Event::PermissionsCreate);
+            ($context->execute)($stmt);
+        }
+    }
+
+    /**
+     * Diff current vs. new permissions and apply additions/removals for a single document.
+     *
+     * @param string $collection The collection name
+     * @param Document $document The updated document with new permissions
+     * @param bool $skipPermissions Whether to skip permission syncing
+     * @param WriteContext $context The write context providing builder and execution closures
+     */
+    public function afterDocumentUpdate(string $collection, Document $document, bool $skipPermissions, WriteContext $context): void
+    {
+        if ($skipPermissions) {
+            return;
+        }
+
+        [$permissionsMap, $storedIds] = $this->readCurrentPermissionsBatch($collection, [$document], $context);
+        $permissions = $this->currentPermissions($permissionsMap, $document->getId());
+        $permissionDocumentId = $this->permissionDocumentId($document->getId(), $storedIds);
+
+        /** @var array<string, list<string>> $removals */
+        $removals = [];
+        /** @var array<string, list<string>> $additions */
+        $additions = [];
+        foreach (self::PERM_TYPES as $type) {
+            $removed = \array_values(\array_diff($permissions[$type->value], $document->getPermissionsByType($type)));
+            if (! empty($removed)) {
+                $removals[$type->value] = $removed;
+            }
+
+            $added = $this->uniqueAdditions($document->getPermissionsByType($type), $permissions[$type->value]);
+            if (! empty($added)) {
+                $additions[$type->value] = $added;
+            }
+        }
+
+        $this->deletePermissions($collection, $permissionDocumentId, $removals, $context);
+        $this->insertPermissions($collection, $document, $permissionDocumentId, $additions, $context);
+    }
+
+    /**
+     * Diff and sync permission rows for a batch of updated documents.
+     *
+     * @param string $collection The collection name
+     * @param Document $updates The update document containing new permission values
+     * @param array<Document> $documents The documents being updated
+     * @param WriteContext $context The write context providing builder and execution closures
+     */
+    public function afterDocumentBatchUpdate(string $collection, Document $updates, array $documents, WriteContext $context): void
+    {
+        if (! $updates->offsetExists(Document::PERMISSIONS)) {
+            return;
+        }
+
+        $removeConditions = [];
+        $addBuilder = ($context->createBuilder)()->into(($context->getTableRaw)(Storage::permissionsTable($collection)));
+        $hasAdditions = false;
+
+        $eligible = [];
+        foreach ($documents as $document) {
+            if ($document->getAttribute(Document::SKIP_PERMISSIONS_UPDATE, false)) {
+                continue;
+            }
+            $eligible[] = $document;
+        }
+
+        if (empty($eligible)) {
+            return;
+        }
+
+        [$permissionsMap, $storedIds] = $this->readCurrentPermissionsBatch($collection, $eligible, $context);
+        $updatesByType = [];
+        foreach (self::PERM_TYPES as $type) {
+            $updatesByType[$type->value] = $updates->getPermissionsByType($type);
+        }
+
+        foreach ($eligible as $document) {
+            $permissions = $this->currentPermissions($permissionsMap, $document->getId());
+            $permissionDocumentId = $this->permissionDocumentId($document->getId(), $storedIds);
+
+            foreach (self::PERM_TYPES as $type) {
+                $diff = \array_diff($permissions[$type->value], $updatesByType[$type->value]);
+                if (! empty($diff)) {
+                    $removeConditions[] = Query::and([
+                        Query::equal(Storage::PERM_DOCUMENT, [$permissionDocumentId]),
+                        Query::equal(Storage::PERM_TYPE, [$type->value]),
+                        Query::equal(Storage::PERM_PERMISSION, \array_values($diff)),
+                    ]);
+                }
+            }
+
+            $metadata = $this->documentMetadata($document);
+            foreach (self::PERM_TYPES as $type) {
+                $diff = $this->uniqueAdditions($updatesByType[$type->value], $permissions[$type->value]);
+                if (! empty($diff)) {
+                    foreach ($diff as $permission) {
+                        $row = ($context->decorateRow)([
+                            Storage::PERM_DOCUMENT => $permissionDocumentId,
+                            Storage::PERM_TYPE => $type->value,
+                            Storage::PERM_PERMISSION => $permission,
+                        ], $metadata);
+                        $addBuilder->set($row);
+                        $hasAdditions = true;
+                    }
+                }
+            }
+        }
+
+        if (! empty($removeConditions)) {
+            $removeBuilder = ($context->newBuilder)(Storage::permissionsTable($collection));
+            $removeBuilder->filter([Query::or($removeConditions)]);
+            $deleteResult = $removeBuilder->delete();
+            $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+            ($context->execute)($deleteStmt);
+        }
+
+        if ($hasAdditions) {
+            $addResult = $addBuilder->insert();
+            $addStmt = ($context->executeResult)($addResult, Event::PermissionsCreate);
+            ($context->execute)($addStmt);
+        }
+    }
+
+    /**
+     * Diff old vs. new permissions from upsert change sets and apply additions/removals.
+     *
+     * @param string $collection The collection name
+     * @param array<\Utopia\Database\Change> $changes The upsert change objects containing old and new documents
+     * @param WriteContext $context The write context providing builder and execution closures
+     */
+    public function afterDocumentUpsert(string $collection, array $changes, WriteContext $context): void
+    {
+        $removeConditions = [];
+        $addBuilder = ($context->createBuilder)()->into(($context->getTableRaw)(Storage::permissionsTable($collection)));
+        $hasAdditions = false;
+
+        foreach ($changes as $change) {
+            $old = $change->getOld();
+            $document = $change->getNew();
+            $metadata = $this->documentMetadata($document);
+
+            $current = [];
+            foreach (self::PERM_TYPES as $type) {
+                $current[$type->value] = $old->getPermissionsByType($type);
+            }
+
+            foreach (self::PERM_TYPES as $type) {
+                $toRemove = \array_diff($current[$type->value], $document->getPermissionsByType($type));
+                if (! empty($toRemove)) {
+                    $removeConditions[] = Query::and([
+                        Query::equal(Storage::PERM_DOCUMENT, [$document->getId()]),
+                        Query::equal(Storage::PERM_TYPE, [$type->value]),
+                        Query::equal(Storage::PERM_PERMISSION, \array_values($toRemove)),
+                    ]);
+                }
+            }
+
+            foreach (self::PERM_TYPES as $type) {
+                $toAdd = $this->uniqueAdditions($document->getPermissionsByType($type), $current[$type->value]);
+                foreach ($toAdd as $permission) {
+                    $row = ($context->decorateRow)([
+                        Storage::PERM_DOCUMENT => $document->getId(),
+                        Storage::PERM_TYPE => $type->value,
+                        Storage::PERM_PERMISSION => $permission,
+                    ], $metadata);
+                    $addBuilder->set($row);
+                    $hasAdditions = true;
+                }
+            }
+        }
+
+        if (! empty($removeConditions)) {
+            $removeBuilder = ($context->newBuilder)(Storage::permissionsTable($collection));
+            $removeBuilder->filter([Query::or($removeConditions)]);
+            $deleteResult = $removeBuilder->delete();
+            $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+            ($context->execute)($deleteStmt);
+        }
+
+        if ($hasAdditions) {
+            $addResult = $addBuilder->insert();
+            $addStmt = ($context->executeResult)($addResult, Event::PermissionsCreate);
+            ($context->execute)($addStmt);
+        }
+    }
+
+    /**
+     * Delete all permission rows for the given document IDs.
+     *
+     * @param string $collection The collection name
+     * @param list<string> $documentIds The IDs of deleted documents
+     * @param WriteContext $context The write context providing builder and execution closures
+     * @throws DatabaseException If the permission deletion fails
+     */
+    public function afterDocumentDelete(string $collection, array $documentIds, WriteContext $context): void
+    {
+        if (empty($documentIds)) {
+            return;
+        }
+
+        $permsBuilder = ($context->newBuilder)(Storage::permissionsTable($collection));
+        $permsBuilder->filter([Query::equal(Storage::PERM_DOCUMENT, $documentIds)]);
+        $permsResult = $permsBuilder->delete();
+        $stmtPermissions = ($context->executeResult)($permsResult, Event::PermissionsDelete);
+
+        if (! ($context->execute)($stmtPermissions)) {
+            throw new DatabaseException('Failed to delete permissions');
+        }
+    }
+
+    /**
+     * Batched version of readCurrentPermissions — issues a single SELECT scoped
+     * to all document ids and groups rows into the same shape per document.
+     *
+     * @param  array<Document>  $documents
+     * @return array{0: array<string, array<string, list<string>>>, 1: array<string, string>}
+     */
+    private function readCurrentPermissionsBatch(string $collection, array $documents, WriteContext $context): array
+    {
+        if (empty($documents)) {
+            return [[], []];
+        }
+
+        $documentIds = $this->permissionReadIds($documents, $context);
+        if ($documentIds === []) {
+            return [[], []];
+        }
+
+        $readBuilder = ($context->newBuilder)(Storage::permissionsTable($collection));
+        $readBuilder->select([Storage::PERM_DOCUMENT, Storage::PERM_TYPE, Storage::PERM_PERMISSION]);
+        $readBuilder->filter([Query::equal(Storage::PERM_DOCUMENT, $documentIds)]);
+
+        $readResult = $readBuilder->build();
+        $readStmt = ($context->executeResult)($readResult, Event::PermissionsRead);
+        ($context->execute)($readStmt);
+        /** @var array<array<string, string>> $rows */
+        $rows = (array) $readStmt->fetchAll();
+        $readStmt->closeCursor();
+
+        return [
+            $this->groupPermissionRows($documentIds, $rows),
+            $this->storedDocumentIds($documentIds, $rows),
+        ];
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @return list<string>
+     */
+    private function permissionReadIds(array $documents, WriteContext $context): array
+    {
+        $documentIds = [];
+        foreach ($documents as $document) {
+            $id = $document->getId();
+            if ($id !== '') {
+                $documentIds[] = $id;
+            }
+        }
+
+        if ($context->lookupId !== null && $context->lookupId !== '') {
+            $documentIds[] = $context->lookupId;
+        }
+
+        return \array_values(\array_unique($documentIds));
+    }
+
+    /**
+     * @param  list<string>  $documentIds
+     * @param  array<array<string, string>>  $rows
+     * @return array<string, string>
+     */
+    private function storedDocumentIds(array $documentIds, array $rows): array
+    {
+        $stored = [];
+        foreach ($rows as $row) {
+            $storedId = $row[Storage::PERM_DOCUMENT] ?? null;
+            if (! \is_string($storedId) || $storedId === '') {
+                continue;
+            }
+
+            foreach ($documentIds as $id) {
+                if (\strcasecmp($storedId, $id) === 0) {
+                    $stored[$id] = $storedId;
+                }
+            }
+        }
+
+        return $stored;
+    }
+
+    /**
+     * @param  array<string, string>  $storedIds
+     */
+    private function permissionDocumentId(string $requestedId, array $storedIds): string
+    {
+        if (isset($storedIds[$requestedId]) && \strcasecmp($storedIds[$requestedId], $requestedId) === 0) {
+            return $storedIds[$requestedId];
+        }
+
+        foreach ($storedIds as $storedId) {
+            if (\strcasecmp($storedId, $requestedId) === 0) {
+                return $storedId;
+            }
+        }
+
+        return $requestedId;
+    }
+
+    /**
+     * @param  list<string>  $documentIds
+     * @param  array<array<string, string>>  $rows
+     * @return array<string, array<string, list<string>>>
+     */
+    private function groupPermissionRows(array $documentIds, array $rows): array
+    {
+        $result = [];
+        $requestedByLower = [];
+        foreach ($documentIds as $id) {
+            $result[$id] = $this->emptyPermissions();
+            $requestedByLower[\strtolower($id)][] = $id;
+        }
+
+        foreach ($rows as $row) {
+            $storedId = $row[Storage::PERM_DOCUMENT] ?? null;
+            $type = $row[Storage::PERM_TYPE] ?? null;
+            $permission = $row[Storage::PERM_PERMISSION] ?? null;
+            if ($storedId === null || $type === null || $permission === null) {
+                continue;
+            }
+
+            $targets = $requestedByLower[\strtolower($storedId)] ?? [];
+            if ($targets === []) {
+                $targets = [$this->resolveStoredDocumentId($storedId, $result, $requestedByLower)];
+            }
+
+            foreach ($targets as $key) {
+                if (! isset($result[$key])) {
+                    $result[$key] = $this->emptyPermissions();
+                }
+                $result[$key][$type][] = $permission;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param  array<string, array<string, list<string>>>  $result
+     * @param  array<string, list<string>>  $requestedByLower
+     */
+    private function resolveStoredDocumentId(string $storedId, array $result, array $requestedByLower): string
+    {
+        if (isset($result[$storedId])) {
+            return $storedId;
+        }
+
+        $candidates = $requestedByLower[\strtolower($storedId)] ?? [];
+        if (\count($candidates) === 1) {
+            return $candidates[0];
+        }
+
+        return $storedId;
+    }
+
+    /**
+     * @param  array<string, array<string, list<string>>>  $map
+     * @return array<string, list<string>>
+     */
+    private function currentPermissions(array $map, string $documentId): array
+    {
+        if (\array_key_exists($documentId, $map)) {
+            return $map[$documentId];
+        }
+
+        foreach ($map as $storedId => $permissions) {
+            if (\strcasecmp((string) $storedId, $documentId) === 0) {
+                return $permissions;
+            }
+        }
+
+        return $this->emptyPermissions();
+    }
+
+    /**
+     * @param  array<array-key, string>  $desired
+     * @param  array<array-key, string>  $current
+     * @return list<string>
+     */
+    private function uniqueAdditions(array $desired, array $current): array
+    {
+        return \array_values(\array_unique(\array_diff($desired, $current)));
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    private function emptyPermissions(): array
+    {
+        $initial = [];
+        foreach (self::PERM_TYPES as $type) {
+            $initial[$type->value] = [];
+        }
+
+        return $initial;
+    }
+
+    /**
+     * @param  array<string, list<string>>  $removals
+     */
+    private function deletePermissions(string $collection, string $documentId, array $removals, WriteContext $context): void
+    {
+        if (empty($removals)) {
+            return;
+        }
+
+        $removeConditions = [];
+        foreach ($removals as $type => $perms) {
+            $removeConditions[] = Query::and([
+                Query::equal(Storage::PERM_DOCUMENT, [$documentId]),
+                Query::equal(Storage::PERM_TYPE, [$type]),
+                Query::equal(Storage::PERM_PERMISSION, $perms),
+            ]);
+        }
+
+        $removeBuilder = ($context->newBuilder)(Storage::permissionsTable($collection));
+        $removeBuilder->filter([Query::or($removeConditions)]);
+        $deleteResult = $removeBuilder->delete();
+        $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+        ($context->execute)($deleteStmt);
+    }
+
+    /**
+     * @param  array<string, list<string>>  $additions
+     */
+    private function insertPermissions(string $collection, Document $document, string $documentId, array $additions, WriteContext $context): void
+    {
+        if (empty($additions)) {
+            return;
+        }
+
+        $addBuilder = ($context->createBuilder)()->into(($context->getTableRaw)(Storage::permissionsTable($collection)));
+        $metadata = $this->documentMetadata($document);
+
+        foreach ($additions as $type => $perms) {
+            foreach (\array_values(\array_unique($perms)) as $permission) {
+                $row = ($context->decorateRow)([
+                    Storage::PERM_DOCUMENT => $documentId,
+                    Storage::PERM_TYPE => $type,
+                    Storage::PERM_PERMISSION => $permission,
+                ], $metadata);
+                $addBuilder->set($row);
+            }
+        }
+
+        $addResult = $addBuilder->insert();
+        $addStmt = ($context->executeResult)($addResult, Event::PermissionsCreate);
+        ($context->execute)($addStmt);
+    }
+
+    /**
+     * Build permission rows for a document, applying decorateRow for tenant etc.
+     *
+     * @return list<array<string, mixed>>
+     */
+    private function buildPermissionRows(Document $document, WriteContext $context): array
+    {
+        $rows = [];
+        $metadata = $this->documentMetadata($document);
+
+        foreach (self::PERM_TYPES as $type) {
+            foreach ($document->getPermissionsByType($type) as $permission) {
+                $row = [
+                    Storage::PERM_DOCUMENT => $document->getId(),
+                    Storage::PERM_TYPE => $type->value,
+                    Storage::PERM_PERMISSION => \str_replace('"', '', $permission),
+                ];
+                $rows[] = ($context->decorateRow)($row, $metadata);
+            }
+        }
+
+        return $rows;
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    private function documentMetadata(Document $document): array
+    {
+        return [
+            'id' => $document->getId(),
+            'tenant' => $document->getTenant(),
+        ];
+    }
+}
diff --git a/src/Database/Hook/Read.php b/src/Database/Hook/Read.php
new file mode 100644
index 0000000000..746e4ae42b
--- /dev/null
+++ b/src/Database/Hook/Read.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Query\Hook;
+
+/**
+ * Read hook interface for MongoDB adapters that apply filters to query filter arrays.
+ */
+interface Read extends Hook
+{
+    /**
+     * Apply read-side filters to a MongoDB filter array.
+     *
+     * @param  array<string, mixed>  $filters  The current MongoDB filter array
+     * @param  string  $collection  The collection being queried
+     * @param  string  $forPermission  The permission type to check (e.g. 'read')
+     * @return array<string, mixed> The modified filter array
+     */
+    public function applyFilters(array $filters, string $collection, string $forPermission = 'read'): array;
+}
diff --git a/src/Database/Hook/Relationships.php b/src/Database/Hook/Relationships.php
new file mode 100644
index 0000000000..5aaad8446f
--- /dev/null
+++ b/src/Database/Hook/Relationships.php
@@ -0,0 +1,2461 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Exception;
+use Utopia\Async\Promise;
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Exception\Relationship as RelationshipException;
+use Utopia\Database\Exception\Restricted as RestrictedException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\Query;
+use Utopia\Database\Relationship as RelationshipVO;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Query\Hook;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+
+/**
+ * Handles relationship side effects for document CRUD, populates nested relationships
+ * on read, and converts relationship filter queries into adapter-compatible subqueries.
+ */
+class Relationships implements Hook
+{
+    private bool $enabled = true;
+
+    private bool $checkExist = true;
+
+    private int $fetchDepth = 0;
+
+    private bool $inBatchPopulation = false;
+
+    /** @var array<string> */
+    private array $writeStack = [];
+
+    /** @var array<Document> */
+    private array $deleteStack = [];
+
+    /**
+     * @param Database $db The database instance used for relationship operations
+     */
+    public function __construct(
+        private Database $db,
+    ) {
+    }
+
+    /**
+     * Effective per-query chunk size for relationship fan-out reads/writes.
+     *
+     * Capped by RELATION_QUERY_CHUNK_SIZE as a memory bound, but never larger
+     * than the configured maxQueryValues — otherwise a caller that lowers the
+     * validator cap would still see relationship updates throw QueryException
+     * on the chunked find/update fallback.
+     */
+    /**
+     * @return int<1, max>
+     */
+    private function relationQueryChunkSize(): int
+    {
+        return \max(1, \min(Database::RELATION_QUERY_CHUNK_SIZE, $this->db->getMaxQueryValues()));
+    }
+
+    private function coerceToDocument(Document $document, string $key, mixed $value): mixed
+    {
+        if (\is_array($value) && ! \array_is_list($value)) {
+            try {
+                $value = new Document($value); // @phpstan-ignore argument.type
+            } catch (StructureException $e) {
+                throw new RelationshipException('Invalid relationship value. ' . $e->getMessage());
+            }
+            $document->setAttribute($key, $value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setEnabled(bool $enabled): void
+    {
+        $this->enabled = $enabled;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function shouldCheckExist(): bool
+    {
+        return $this->checkExist;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setCheckExist(bool $check): void
+    {
+        $this->checkExist = $check;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getWriteStackCount(): int
+    {
+        return \count($this->writeStack);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getFetchDepth(): int
+    {
+        return $this->fetchDepth;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function isInBatchPopulation(): bool
+    {
+        return $this->inBatchPopulation;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws DuplicateException If a related document already exists
+     * @throws RelationshipException If a relationship constraint is violated
+     */
+    public function afterDocumentCreate(Document $collection, Document $document): Document
+    {
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            Attribute::isRelationship(...)
+        );
+
+        $stackCount = \count($this->writeStack);
+
+        foreach ($relationships as $relationship) {
+            /** @var string $key */
+            $key = $relationship->getAttribute('key', $relationship->getId());
+            $value = $document->getAttribute($key);
+            $rel = RelationshipVO::fromArray(['collection' => $collection->getId()] + $relationship->getArrayCopy());
+            $relatedCollection = $this->db->getCollection($rel->relatedCollection);
+            $relationType = $rel->type;
+            $twoWay = $rel->twoWay;
+            $twoWayKey = $rel->twoWayKey;
+            $side = $rel->side;
+
+            if ($stackCount >= Database::RELATION_MAX_DEPTH - 1 && $this->writeStack[$stackCount - 1] !== $relatedCollection->getId()) {
+                $document->removeAttribute($key);
+
+                continue;
+            }
+
+            $this->writeStack[] = $collection->getId();
+
+            try {
+                $value = $this->coerceToDocument($document, $key, $value);
+
+                if (\is_array($value)) {
+                    if (
+                        ($relationType === RelationType::ManyToOne && $side === RelationSide::Parent) ||
+                        ($relationType === RelationType::OneToMany && $side === RelationSide::Child) ||
+                        ($relationType === RelationType::OneToOne)
+                    ) {
+                        throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document, array given.');
+                    }
+
+                    foreach ($value as $related) {
+                        if ($related instanceof Document) {
+                            $this->relateDocuments(
+                                $collection,
+                                $relatedCollection,
+                                $key,
+                                $document,
+                                $related,
+                                $relationType,
+                                $twoWay,
+                                $twoWayKey,
+                                $side,
+                            );
+                        } elseif (\is_string($related)) {
+                            $this->relateDocumentsById(
+                                $collection,
+                                $relatedCollection,
+                                $key,
+                                $document->getId(),
+                                $related,
+                                $relationType,
+                                $twoWay,
+                                $twoWayKey,
+                                $side,
+                            );
+                        } else {
+                            throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
+                        }
+                    }
+                    $document->removeAttribute($key);
+                } elseif ($value instanceof Document) {
+                    if ($relationType === RelationType::OneToOne && ! $twoWay && $side === RelationSide::Child) {
+                        throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
+                    }
+
+                    if (
+                        ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) ||
+                        ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) ||
+                        ($relationType === RelationType::ManyToMany)
+                    ) {
+                        throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, document given.');
+                    }
+
+                    $relatedId = $this->relateDocuments(
+                        $collection,
+                        $relatedCollection,
+                        $key,
+                        $document,
+                        $value,
+                        $relationType,
+                        $twoWay,
+                        $twoWayKey,
+                        $side,
+                    );
+                    $document->setAttribute($key, $relatedId);
+                } elseif (\is_string($value)) {
+                    if ($relationType === RelationType::OneToOne && $twoWay === false && $side === RelationSide::Child) {
+                        throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
+                    }
+
+                    if (
+                        ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) ||
+                        ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) ||
+                        ($relationType === RelationType::ManyToMany)
+                    ) {
+                        throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, document ID given.');
+                    }
+
+                    $this->relateDocumentsById(
+                        $collection,
+                        $relatedCollection,
+                        $key,
+                        $document->getId(),
+                        $value,
+                        $relationType,
+                        $twoWay,
+                        $twoWayKey,
+                        $side,
+                    );
+                } elseif ($value === null) {
+                    if (
+                        !(($relationType === RelationType::OneToMany && $side === RelationSide::Child) ||
+                        ($relationType === RelationType::ManyToOne && $side === RelationSide::Parent) ||
+                        ($relationType === RelationType::OneToOne && $side === RelationSide::Parent) ||
+                        ($relationType === RelationType::OneToOne && $twoWay === true))
+                    ) {
+                        $document->removeAttribute($key);
+                    }
+                } else {
+                    throw new RelationshipException('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
+                }
+            } finally {
+                \array_pop($this->writeStack);
+            }
+        }
+
+        return $document;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws DuplicateException If a related document already exists
+     * @throws RelationshipException If a relationship constraint is violated
+     * @throws RestrictedException If a restricted relationship is violated
+     */
+    public function afterDocumentUpdate(Document $collection, Document $old, Document $document): Document
+    {
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            Attribute::isRelationship(...)
+        );
+
+        $stackCount = \count($this->writeStack);
+
+        foreach ($relationships as $index => $relationship) {
+            /** @var string $key */
+            $key = $relationship->getAttribute('key', $relationship->getId());
+            $value = $document->getAttribute($key);
+
+            $value = $this->coerceToDocument($document, $key, $value);
+
+            $oldValue = $old->getAttribute($key);
+            $rel = RelationshipVO::fromArray(['collection' => $collection->getId()] + $relationship->getArrayCopy());
+            $relatedCollection = $this->db->getCollection($rel->relatedCollection);
+            $relationType = $rel->type;
+            $twoWay = $rel->twoWay;
+            $twoWayKey = $rel->twoWayKey;
+            $side = $rel->side;
+
+            if (Operator::isOperator($value)) {
+                /** @var Operator $operator */
+                $operator = $value;
+                if ($operator->isArrayOperation()) {
+                    $existingIds = [];
+                    if (\is_array($oldValue)) {
+                        /** @var array<Document|string> $oldValue */
+                        $existingIds = \array_map(fn ($item) => $item instanceof Document ? $item->getId() : (string) $item, $oldValue);
+                    }
+
+                    $value = $this->applyRelationshipOperator($operator, $existingIds);
+                    $document->setAttribute($key, $value);
+                }
+            }
+
+            if ($oldValue == $value) {
+                if (
+                    ($relationType === RelationType::OneToOne
+                        || ($relationType === RelationType::ManyToOne && $side === RelationSide::Parent)) &&
+                    $value instanceof Document
+                ) {
+                    $document->setAttribute($key, $value->getId());
+
+                    continue;
+                }
+                $document->removeAttribute($key);
+
+                continue;
+            }
+
+            if ($stackCount >= Database::RELATION_MAX_DEPTH - 1 && $this->writeStack[$stackCount - 1] !== $relatedCollection->getId()) {
+                $document->removeAttribute($key);
+
+                continue;
+            }
+
+            $this->writeStack[] = $collection->getId();
+
+            try {
+                switch ($relationType) {
+                    case RelationType::OneToOne:
+                        if (! $twoWay) {
+                            if ($side === RelationSide::Child) {
+                                throw new RelationshipException('Invalid relationship value. Cannot set a value from the child side of a oneToOne relationship when twoWay is false.');
+                            }
+
+                            if (\is_string($value)) {
+                                $related = $this->db->skipRelationships(fn () => $this->db->getDocument($relatedCollection->getId(), $value, [Query::select([Document::ID])]));
+                                if ($related->isEmpty()) {
+                                    $document->setAttribute($key, null);
+                                }
+                            } elseif ($value instanceof Document) {
+                                $relationId = $this->relateDocuments(
+                                    $collection,
+                                    $relatedCollection,
+                                    $key,
+                                    $document,
+                                    $value,
+                                    $relationType,
+                                    false,
+                                    $twoWayKey,
+                                    $side,
+                                );
+                                $document->setAttribute($key, $relationId);
+                            } elseif (is_array($value)) {
+                                throw new RelationshipException('Invalid relationship value. Must be either a document, document ID or null. Array given.');
+                            }
+
+                            break;
+                        }
+
+                        if (\is_string($value)) {
+                            $related = $this->db->skipRelationships(
+                                fn () => $this->db->getDocument($relatedCollection->getId(), $value, [Query::select([Document::ID])])
+                            );
+
+                            if ($related->isEmpty()) {
+                                $document->setAttribute($key, null);
+                            } else {
+                                /** @var Document|null $oldValueDoc */
+                                $oldValueDoc = $oldValue instanceof Document ? $oldValue : null;
+                                if (
+                                    $oldValueDoc?->getId() !== $value
+                                    && ! ($this->db->skipRelationships(fn () => $this->db->findOne($relatedCollection->getId(), [
+                                        Query::select([Document::ID]),
+                                        Query::equal($twoWayKey, [$value]),
+                                    ]))->isEmpty())
+                                ) {
+                                    throw new DuplicateException('Document already has a related document');
+                                }
+
+                                $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                                    $relatedCollection->getId(),
+                                    $related->getId(),
+                                    $related->setAttribute($twoWayKey, $document->getId())
+                                ));
+                            }
+                        } elseif ($value instanceof Document) {
+                            $related = $this->db->skipRelationships(fn () => $this->db->getDocument($relatedCollection->getId(), $value->getId()));
+
+                            /** @var Document|null $oldValueDoc2 */
+                            $oldValueDoc2 = $oldValue instanceof Document ? $oldValue : null;
+                            if (
+                                $oldValueDoc2?->getId() !== $value->getId()
+                                && ! ($this->db->skipRelationships(fn () => $this->db->findOne($relatedCollection->getId(), [
+                                    Query::select([Document::ID]),
+                                    Query::equal($twoWayKey, [$value->getId()]),
+                                ]))->isEmpty())
+                            ) {
+                                throw new DuplicateException('Document already has a related document');
+                            }
+
+                            $this->writeStack[] = $relatedCollection->getId();
+                            if ($related->isEmpty()) {
+                                if (! isset($value[Document::PERMISSIONS])) {
+                                    $value->setAttribute(Document::PERMISSIONS, $document->getAttribute(Document::PERMISSIONS));
+                                }
+                                $related = $this->db->createDocument(
+                                    $relatedCollection->getId(),
+                                    $value->setAttribute($twoWayKey, $document->getId())
+                                );
+                            } else {
+                                $related = $this->db->updateDocument(
+                                    $relatedCollection->getId(),
+                                    $related->getId(),
+                                    $value->setAttribute($twoWayKey, $document->getId())
+                                );
+                            }
+                            \array_pop($this->writeStack);
+
+                            $document->setAttribute($key, $related->getId());
+                        } elseif ($value === null) {
+                            /** @var Document|null $oldValueDocNull */
+                            $oldValueDocNull = $oldValue instanceof Document ? $oldValue : null;
+                            if ($oldValueDocNull?->getId() !== null) {
+                                $oldRelated = $this->db->skipRelationships(
+                                    fn () => $this->db->getDocument($relatedCollection->getId(), $oldValueDocNull->getId())
+                                );
+                                $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                                    $relatedCollection->getId(),
+                                    $oldRelated->getId(),
+                                    new Document([$twoWayKey => null])
+                                ));
+                            }
+                        } else {
+                            throw new RelationshipException('Invalid relationship value. Must be either a document, document ID or null.');
+                        }
+                        break;
+                    case RelationType::OneToMany:
+                    case RelationType::ManyToOne:
+                        if (
+                            ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) ||
+                            ($relationType === RelationType::ManyToOne && $side === RelationSide::Child)
+                        ) {
+                            if (! \is_array($value) || ! \array_is_list($value)) {
+                                throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, '.\gettype($value).' given.');
+                            }
+
+                            /** @var array<Document> $oldValueArr */
+                            $oldValueArr = \is_array($oldValue) ? $oldValue : [];
+                            $oldIds = \array_map(fn (Document $document) => $document->getId(), $oldValueArr);
+
+                            $newIds = \array_map(function ($item) {
+                                if (\is_string($item)) {
+                                    return $item;
+                                } elseif ($item instanceof Document) {
+                                    return $item->getId();
+                                } else {
+                                    throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
+                                }
+                            }, $value);
+
+                            $removedDocuments = \array_values(\array_diff($oldIds, $newIds));
+
+                            if (! empty($removedDocuments)) {
+                                // Chunk to honor the validator's maxQueryValues cap; without
+                                // this a relationship update with thousands of removed
+                                // children would throw QueryException.
+                                foreach (\array_chunk($removedDocuments, $this->relationQueryChunkSize()) as $chunk) {
+                                    $this->db->getAuthorization()->skip(fn () => $this->db->skipRelationships(fn () => $this->db->updateDocuments(
+                                        $relatedCollection->getId(),
+                                        new Document([$twoWayKey => null]),
+                                        [Query::equal(Document::ID, $chunk)],
+                                    )));
+                                }
+                            }
+
+                            $stringRelations = [];
+                            $documentRelations = [];
+                            foreach ($value as $relation) {
+                                if (\is_string($relation)) {
+                                    $stringRelations[] = $relation;
+                                } elseif ($relation instanceof Document) {
+                                    $documentRelations[] = $relation;
+                                } else {
+                                    throw new RelationshipException('Invalid relationship value.');
+                                }
+                            }
+
+                            if (! empty($stringRelations)) {
+                                $existingIds = [];
+                                foreach (\array_chunk($stringRelations, $this->relationQueryChunkSize()) as $chunk) {
+                                    $existing = $this->db->skipRelationships(
+                                        fn () => $this->db->find($relatedCollection->getId(), [
+                                            Query::select([Document::ID]),
+                                            Query::equal(Document::ID, $chunk),
+                                            Query::limit(\count($chunk)),
+                                        ])
+                                    );
+                                    foreach ($existing as $doc) {
+                                        $existingIds[] = $doc->getId();
+                                    }
+                                }
+
+                                if (! empty($existingIds)) {
+                                    foreach (\array_chunk($existingIds, $this->relationQueryChunkSize()) as $chunk) {
+                                        $this->db->skipRelationships(fn () => $this->db->updateDocuments(
+                                            $relatedCollection->getId(),
+                                            new Document([$twoWayKey => $document->getId()]),
+                                            [Query::equal(Document::ID, $chunk)],
+                                        ));
+                                    }
+                                }
+                            }
+
+                            foreach ($documentRelations as $relation) {
+                                $related = $this->db->skipRelationships(
+                                    fn () => $this->db->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select([Document::ID])])
+                                );
+
+                                if ($related->isEmpty()) {
+                                    if (! isset($relation[Document::PERMISSIONS])) {
+                                        $relation->setAttribute(Document::PERMISSIONS, $document->getAttribute(Document::PERMISSIONS));
+                                    }
+                                    $this->db->createDocument(
+                                        $relatedCollection->getId(),
+                                        $relation->setAttribute($twoWayKey, $document->getId())
+                                    );
+                                } else {
+                                    $this->db->updateDocument(
+                                        $relatedCollection->getId(),
+                                        $related->getId(),
+                                        $relation->setAttribute($twoWayKey, $document->getId())
+                                    );
+                                }
+                            }
+
+                            $document->removeAttribute($key);
+                            break;
+                        }
+
+                        if (\is_string($value)) {
+                            $related = $this->db->skipRelationships(
+                                fn () => $this->db->getDocument($relatedCollection->getId(), $value, [Query::select([Document::ID])])
+                            );
+
+                            if ($related->isEmpty()) {
+                                $document->setAttribute($key, null);
+                            }
+                            $this->db->purgeCachedDocument($relatedCollection->getId(), $value);
+                        } elseif ($value instanceof Document) {
+                            if ($value->getId() === '') {
+                                throw new RelationshipException('Invalid relationship value. Document must have a valid '.Document::ID.'.');
+                            }
+
+                            $related = $this->db->skipRelationships(
+                                fn () => $this->db->getDocument($relatedCollection->getId(), $value->getId(), [Query::select([Document::ID])])
+                            );
+
+                            if ($related->isEmpty()) {
+                                if (! isset($value[Document::PERMISSIONS])) {
+                                    $value->setAttribute(Document::PERMISSIONS, $document->getAttribute(Document::PERMISSIONS));
+                                }
+                                $this->db->createDocument(
+                                    $relatedCollection->getId(),
+                                    $value
+                                );
+                            } elseif ($related->getAttributes() != $value->getAttributes()) {
+                                $this->db->updateDocument(
+                                    $relatedCollection->getId(),
+                                    $related->getId(),
+                                    $value
+                                );
+                                $this->db->purgeCachedDocument($relatedCollection->getId(), $related->getId());
+                            }
+
+                            $document->setAttribute($key, $value->getId());
+                        } elseif ($value === null) {
+                            break;
+                        } elseif (is_array($value)) {
+                            throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document, array given.');
+                        } elseif (empty($value)) {
+                            throw new RelationshipException('Invalid relationship value. Must be either a document ID or a document.');
+                        } else {
+                            throw new RelationshipException('Invalid relationship value.');
+                        }
+
+                        break;
+                    case RelationType::ManyToMany:
+                        if ($value === null) {
+                            break;
+                        }
+                        if (! \is_array($value)) {
+                            throw new RelationshipException('Invalid relationship value. Must be an array of documents or document IDs.');
+                        }
+
+                        /** @var array<Document> $oldValueArrM2M */
+                        $oldValueArrM2M = \is_array($oldValue) ? $oldValue : [];
+                        $oldIds = \array_map(fn (Document $document) => $document->getId(), $oldValueArrM2M);
+
+                        $newIds = \array_map(function ($item) {
+                            if (\is_string($item)) {
+                                return $item;
+                            } elseif ($item instanceof Document) {
+                                return $item->getId();
+                            } else {
+                                throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
+                            }
+                        }, $value);
+
+                        $removedDocuments = \array_values(\array_diff($oldIds, $newIds));
+
+                        if (! empty($removedDocuments)) {
+                            $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                            // Chunk both the lookup and the delete so a many-to-many
+                            // diff with thousands of removed peers stays within the
+                            // validator's maxQueryValues ceiling.
+                            $junctionIds = [];
+                            foreach (\array_chunk($removedDocuments, $this->relationQueryChunkSize()) as $chunk) {
+                                $junctions = $this->db->find($junction, [
+                                    Query::select([Document::ID]),
+                                    Query::equal($key, $chunk),
+                                    Query::equal($twoWayKey, [$document->getId()]),
+                                    Query::limit(PHP_INT_MAX),
+                                ]);
+                                foreach ($junctions as $junctionDoc) {
+                                    $junctionIds[] = $junctionDoc->getId();
+                                }
+                            }
+
+                            if (! empty($junctionIds)) {
+                                foreach (\array_chunk($junctionIds, $this->relationQueryChunkSize()) as $chunk) {
+                                    $this->db->getAuthorization()->skip(fn () => $this->db->deleteDocuments(
+                                        $junction,
+                                        [Query::equal(Document::ID, $chunk)],
+                                    ));
+                                }
+                            }
+                        }
+
+                        foreach ($value as $relation) {
+                            if (\is_string($relation)) {
+                                if (\in_array($relation, $oldIds) || $this->db->getDocument($relatedCollection->getId(), $relation, [Query::select([Document::ID])])->isEmpty()) {
+                                    continue;
+                                }
+                            } elseif ($relation instanceof Document) {
+                                $related = $this->db->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select([Document::ID])]);
+
+                                if ($related->isEmpty()) {
+                                    if (! isset($value[Document::PERMISSIONS])) {
+                                        $relation->setAttribute(Document::PERMISSIONS, $document->getAttribute(Document::PERMISSIONS));
+                                    }
+                                    $related = $this->db->createDocument(
+                                        $relatedCollection->getId(),
+                                        $relation
+                                    );
+                                } elseif ($related->getAttributes() != $relation->getAttributes()) {
+                                    $related = $this->db->updateDocument(
+                                        $relatedCollection->getId(),
+                                        $related->getId(),
+                                        $relation
+                                    );
+                                }
+
+                                if (\in_array($relation->getId(), $oldIds)) {
+                                    continue;
+                                }
+
+                                $relation = $related->getId();
+                            } else {
+                                throw new RelationshipException('Invalid relationship value. Must be either a document or document ID.');
+                            }
+
+                            $this->db->skipRelationships(fn () => $this->db->createDocument(
+                                $this->getJunctionCollection($collection, $relatedCollection, $side),
+                                new Document([
+                                    $key => $relation,
+                                    $twoWayKey => $document->getId(),
+                                    Document::PERMISSIONS => [
+                                        Permission::read(Role::any()),
+                                        Permission::update(Role::any()),
+                                        Permission::delete(Role::any()),
+                                    ],
+                                ])
+                            ));
+                        }
+
+                        $document->removeAttribute($key);
+                        break;
+                }
+            } finally {
+                \array_pop($this->writeStack);
+            }
+        }
+
+        return $document;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws RestrictedException If a restricted relationship prevents deletion
+     */
+    public function beforeDocumentDelete(Document $collection, Document $document): Document
+    {
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            Attribute::isRelationship(...)
+        );
+
+        foreach ($relationships as $relationship) {
+            $key = $relationship->getId();
+            $value = $document->getAttribute($key);
+            $rel = RelationshipVO::fromArray(['collection' => $collection->getId()] + $relationship->getArrayCopy());
+            $relatedCollection = $this->db->getCollection($rel->relatedCollection);
+            $relationType = $rel->type;
+            $twoWay = $rel->twoWay;
+            $twoWayKey = $rel->twoWayKey;
+            $onDelete = $rel->onDelete;
+            $side = $rel->side;
+
+            $relationship->setAttribute('collection', $collection->getId());
+            $relationship->setAttribute('document', $document->getId());
+
+            switch ($onDelete) {
+                case ForeignKeyAction::Restrict:
+                    $this->deleteRestrict($relatedCollection, $document, $value, $relationType, $twoWay, $twoWayKey, $side);
+                    break;
+                case ForeignKeyAction::SetNull:
+                    $this->deleteSetNull($collection, $relatedCollection, $document, $value, $relationType, $twoWay, $twoWayKey, $side);
+                    break;
+                case ForeignKeyAction::Cascade:
+                    foreach ($this->deleteStack as $processedRelationship) {
+                        /** @var string $existingKey */
+                        $existingKey = $processedRelationship['key'];
+                        /** @var string $existingCollection */
+                        $existingCollection = $processedRelationship['collection'];
+                        $existingRel = RelationshipVO::fromArray(['collection' => $existingCollection] + $processedRelationship->getArrayCopy());
+                        $existingRelatedCollection = $existingRel->relatedCollection;
+                        $existingTwoWayKey = $existingRel->twoWayKey;
+                        $existingSide = $existingRel->side;
+
+                        $reflexive = $processedRelationship == $relationship;
+
+                        $symmetric = $existingKey === $twoWayKey
+                            && $existingTwoWayKey === $key
+                            && $existingRelatedCollection === $collection->getId()
+                            && $existingCollection === $relatedCollection->getId()
+                            && $existingSide !== $side;
+
+                        $transitive = (($existingKey === $twoWayKey
+                                && $existingCollection === $relatedCollection->getId()
+                                && $existingSide !== $side)
+                            || ($existingTwoWayKey === $key
+                                && $existingRelatedCollection === $collection->getId()
+                                && $existingSide !== $side)
+                            || ($existingKey === $key
+                                && $existingTwoWayKey !== $twoWayKey
+                                && $existingRelatedCollection === $relatedCollection->getId()
+                                && $existingSide !== $side)
+                            || ($existingKey !== $key
+                                && $existingTwoWayKey === $twoWayKey
+                                && $existingRelatedCollection === $relatedCollection->getId()
+                                && $existingSide !== $side));
+
+                        if ($reflexive || $symmetric || $transitive) {
+                            break 2;
+                        }
+                    }
+                    $this->deleteCascade($collection, $relatedCollection, $document, $key, $value, $relationType, $twoWayKey, $side, $relationship);
+                    break;
+            }
+        }
+
+        return $document;
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<string, array<Query>>  $selects
+     * @return array<Document>
+     */
+    public function populateDocuments(array $documents, Document $collection, int $fetchDepth, array $selects = []): array
+    {
+        $this->inBatchPopulation = true;
+
+        try {
+            $queue = [
+                [
+                    'documents' => $documents,
+                    'collection' => $collection,
+                    'depth' => $fetchDepth,
+                    'selects' => $selects,
+                    'skipKey' => null,
+                    'hasExplicitSelects' => ! empty($selects),
+                ],
+            ];
+
+            $currentDepth = $fetchDepth;
+
+            while (! empty($queue) && $currentDepth < Database::RELATION_MAX_DEPTH) {
+                $nextQueue = [];
+
+                foreach ($queue as $item) {
+                    $docs = $item['documents'];
+                    $coll = $item['collection'];
+                    $sels = $item['selects'];
+                    $skipKey = $item['skipKey'] ?? null;
+                    $parentHasExplicitSelects = $item['hasExplicitSelects'];
+
+                    if (empty($docs)) {
+                        continue;
+                    }
+
+                    /** @var array<Document> $popAttributes */
+                    $popAttributes = $coll->getAttribute('attributes', []);
+                    /** @var array<Document> $relationships */
+                    $relationships = [];
+
+                    foreach ($popAttributes as $attribute) {
+                        // Avoid the Attribute::fromDocument allocation —
+                        // we only need the type and key here, both of
+                        // which are plain Document attributes.
+                        if (! Attribute::isRelationship($attribute)) {
+                            continue;
+                        }
+
+                        /** @var string $popKey */
+                        $popKey = $attribute->getAttribute('key', $attribute->getId());
+
+                        if ($popKey === $skipKey) {
+                            continue;
+                        }
+
+                        if (! $parentHasExplicitSelects || \array_key_exists($popKey, $sels)) {
+                            $relationships[] = $attribute;
+                        }
+                    }
+
+                    foreach ($relationships as $relationship) {
+                        /** @var string $key */
+                        $key = $relationship->getAttribute('key', $relationship->getId());
+                        $queries = $sels[$key] ?? [];
+                        $relationship->setAttribute('collection', $coll->getId());
+                        $isAtMaxDepth = ($currentDepth + 1) >= Database::RELATION_MAX_DEPTH;
+
+                        if ($isAtMaxDepth) {
+                            foreach ($docs as $doc) {
+                                $doc->removeAttribute($key);
+                            }
+
+                            continue;
+                        }
+
+                        $relVO = RelationshipVO::fromArray(['collection' => $coll->getId()] + $relationship->getArrayCopy());
+
+                        $relatedDocs = $this->populateSingleRelationshipBatch(
+                            $docs,
+                            $relVO,
+                            $queries
+                        );
+
+                        $twoWay = $relVO->twoWay;
+                        $twoWayKey = $relVO->twoWayKey;
+
+                        $hasNestedSelectsForThisRel = isset($sels[$key]);
+                        $shouldQueue = ! empty($relatedDocs) &&
+                            ($hasNestedSelectsForThisRel || ! $parentHasExplicitSelects);
+
+                        if ($shouldQueue) {
+                            $relatedCollectionId = $relVO->relatedCollection;
+                            $relatedCollection = $this->db->silent(fn () => $this->db->getCollection($relatedCollectionId));
+
+                            if (! $relatedCollection->isEmpty()) {
+                                $relationshipQueries = $hasNestedSelectsForThisRel ? $sels[$key] : [];
+
+                                /** @var array<Document> $relatedCollectionRelationships */
+                                $relatedCollectionRelationships = $relatedCollection->getAttribute('attributes', []);
+                                /** @var array<Document> $relatedCollectionRelationships */
+                                $relatedCollectionRelationships = \array_filter(
+                                    $relatedCollectionRelationships,
+                                    Attribute::isRelationship(...)
+                                );
+
+                                $nextSelects = $this->processQueries($relatedCollectionRelationships, $relationshipQueries);
+
+                                $childHasExplicitSelects = $parentHasExplicitSelects;
+
+                                $nextQueue[] = [
+                                    'documents' => $relatedDocs,
+                                    'collection' => $relatedCollection,
+                                    'depth' => $currentDepth + 1,
+                                    'selects' => $nextSelects,
+                                    'skipKey' => $twoWay ? $twoWayKey : null,
+                                    'hasExplicitSelects' => $childHasExplicitSelects,
+                                ];
+                            }
+                        }
+
+                        if ($twoWay && ! empty($relatedDocs)) {
+                            foreach ($relatedDocs as $relatedDoc) {
+                                $relatedDoc->removeAttribute($twoWayKey);
+                            }
+                        }
+                    }
+                }
+
+                $queue = $nextQueue;
+                $currentDepth++;
+            }
+        } finally {
+            $this->inBatchPopulation = false;
+        }
+
+        return $documents;
+    }
+
+    /**
+     * @param  array<Document>  $relationships
+     * @param  array<Query>  $queries
+     * @return array<string, array<Query>>
+     */
+    public function processQueries(array $relationships, array $queries): array
+    {
+        $nestedSelections = [];
+
+        // Fast exit: collections without relationships short-circuit before
+        // walking the query list. This is the common case for flat tables.
+        if (empty($relationships)) {
+            return $nestedSelections;
+        }
+
+        // Pre-index relationships by key once so per-value lookups are O(1)
+        // instead of O(relationships) with a fresh array_filter each iteration.
+        /** @var array<string, Document> $relationshipsByKey */
+        $relationshipsByKey = [];
+        /** @var Document $relationship */
+        foreach ($relationships as $relationship) {
+            /** @var string $relKey */
+            $relKey = $relationship->getAttribute('key', $relationship->getId());
+            $relationshipsByKey[$relKey] = $relationship;
+        }
+
+        foreach ($queries as $query) {
+            if ($query->getMethod() !== Method::Select) {
+                continue;
+            }
+
+            $values = $query->getValues();
+            foreach ($values as $valueIndex => $value) {
+                if (! \is_string($value)) {
+                    throw new QueryException('Select queries must contain only string attributes.');
+                }
+
+                if (! \str_contains($value, '.')) {
+                    continue;
+                }
+
+                $nesting = \explode('.', $value);
+                $selectedKey = \array_shift($nesting);
+
+                $relationship = $relationshipsByKey[$selectedKey] ?? null;
+
+                if (! $relationship) {
+                    continue;
+                }
+
+                $nestingPath = \implode('.', $nesting);
+
+                if (empty($nestingPath)) {
+                    $nestedSelections[$selectedKey][] = Query::select(['*']);
+                } else {
+                    $nestedSelections[$selectedKey][] = Query::select([$nestingPath]);
+                }
+
+                $relVO = RelationshipVO::fromArray(['collection' => ''] + $relationship->getArrayCopy());
+
+                switch ($relVO->type) {
+                    case RelationType::ManyToMany:
+                        unset($values[$valueIndex]);
+                        break;
+                    case RelationType::OneToMany:
+                        if ($relVO->side === RelationSide::Parent) {
+                            unset($values[$valueIndex]);
+                        } else {
+                            $values[$valueIndex] = $selectedKey;
+                        }
+                        break;
+                    case RelationType::ManyToOne:
+                        if ($relVO->side === RelationSide::Parent) {
+                            $values[$valueIndex] = $selectedKey;
+                        } else {
+                            unset($values[$valueIndex]);
+                        }
+                        break;
+                    case RelationType::OneToOne:
+                        $values[$valueIndex] = $selectedKey;
+                        break;
+                }
+            }
+
+            $finalValues = \array_values($values);
+            if (empty($finalValues)) {
+                $finalValues = ['*'];
+            }
+            $query->setValues($finalValues);
+        }
+
+        return $nestedSelections;
+    }
+
+    /**
+     * @param  array<Document>  $relationships
+     * @param  array<Query>  $queries
+     * @return array<Query>|null
+     *
+     * @throws QueryException If a relationship query references an invalid attribute
+     */
+    public function convertQueries(array $relationships, array $queries, ?Document $collection = null): ?array
+    {
+        // Fast exit: nothing to convert when the collection has no
+        // relationship attributes — saves the per-find query walk.
+        if (empty($relationships)) {
+            return $queries;
+        }
+
+        $hasRelationshipQuery = false;
+        foreach ($queries as $query) {
+            $attr = $query->getAttribute();
+            if (\str_contains($attr, '.') || $query->getMethod() === Method::ContainsAll) {
+                $hasRelationshipQuery = true;
+                break;
+            }
+        }
+
+        if (! $hasRelationshipQuery) {
+            return $queries;
+        }
+
+        $collectionId = $collection?->getId() ?? '';
+
+        /** @var array<string, RelationshipVO> $relationshipsByKey */
+        $relationshipsByKey = [];
+        foreach ($relationships as $relationship) {
+            $relVO = RelationshipVO::fromArray(['collection' => $collectionId] + $relationship->getArrayCopy());
+            $relationshipsByKey[$relVO->key] = $relVO;
+        }
+
+        $additionalQueries = [];
+        $groupedQueries = [];
+        $indicesToRemove = [];
+
+        foreach ($queries as $index => $query) {
+            if ($query->getMethod() !== Method::ContainsAll) {
+                continue;
+            }
+
+            $attribute = $query->getAttribute();
+
+            if (! \str_contains($attribute, '.')) {
+                continue;
+            }
+
+            $parts = \explode('.', $attribute);
+            $relationshipKey = \array_shift($parts);
+            $nestedAttribute = \implode('.', $parts);
+            $relationship = $relationshipsByKey[$relationshipKey] ?? null;
+
+            if (! $relationship) {
+                continue;
+            }
+
+            $parentIdSets = [];
+            $resolvedAttribute = Document::ID;
+            foreach ($query->getValues() as $value) {
+                /** @var string|int|float|bool|null $value */
+                $relatedQuery = Query::equal($nestedAttribute, [$value]);
+                $result = $this->resolveRelationshipGroupToIds($relationship, [$relatedQuery], $collection);
+
+                if ($result === null) {
+                    return null;
+                }
+
+                $resolvedAttribute = $result['attribute'];
+                $parentIdSets[] = $result['ids'];
+            }
+
+            $ids = \count($parentIdSets) > 1
+                ? \array_values(\array_intersect(...$parentIdSets))
+                : ($parentIdSets[0] ?? []);
+
+            if (empty($ids)) {
+                return null;
+            }
+
+            $additionalQueries[] = Query::equal($resolvedAttribute, $ids);
+            $indicesToRemove[] = $index;
+        }
+
+        foreach ($queries as $index => $query) {
+            if ($query->getMethod() === Method::Select || $query->getMethod() === Method::ContainsAll) {
+                continue;
+            }
+
+            $attribute = $query->getAttribute();
+
+            if (! \str_contains($attribute, '.')) {
+                continue;
+            }
+
+            $parts = \explode('.', $attribute);
+            $relationshipKey = \array_shift($parts);
+            $nestedAttribute = \implode('.', $parts);
+            $relationship = $relationshipsByKey[$relationshipKey] ?? null;
+
+            if (! $relationship) {
+                continue;
+            }
+
+            if (! isset($groupedQueries[$relationshipKey])) {
+                $groupedQueries[$relationshipKey] = [
+                    'relationship' => $relationship,
+                    'queries' => [],
+                    'indices' => [],
+                ];
+            }
+
+            $groupedQueries[$relationshipKey]['queries'][] = [
+                'method' => $query->getMethod(),
+                'attribute' => $nestedAttribute,
+                'values' => $query->getValues(),
+            ];
+
+            $groupedQueries[$relationshipKey]['indices'][] = $index;
+        }
+
+        foreach ($groupedQueries as $relationshipKey => $group) {
+            $relationship = $group['relationship'];
+
+            $equalAttrs = [];
+            foreach ($group['queries'] as $queryData) {
+                if ($queryData['method'] === Method::Equal) {
+                    $attr = $queryData['attribute'];
+                    if (isset($equalAttrs[$attr])) {
+                        throw new QueryException("Multiple equal queries on '{$relationshipKey}.{$attr}' will never match a single document. Use Query::containsAll() to match across different related documents.");
+                    }
+                    $equalAttrs[$attr] = true;
+                }
+            }
+
+            $relatedQueries = [];
+            foreach ($group['queries'] as $queryData) {
+                $relatedQueries[] = new Query(
+                    $queryData['method'],
+                    $queryData['attribute'],
+                    $queryData['values']
+                );
+            }
+
+            try {
+                $result = $this->resolveRelationshipGroupToIds($relationship, $relatedQueries, $collection);
+
+                if ($result === null) {
+                    return null;
+                }
+
+                $additionalQueries[] = Query::equal($result['attribute'], $result['ids']);
+
+                foreach ($group['indices'] as $originalIndex) {
+                    $indicesToRemove[] = $originalIndex;
+                }
+            } catch (QueryException $e) {
+                throw $e;
+            } catch (Exception $e) {
+                return null;
+            }
+        }
+
+        foreach ($indicesToRemove as $index) {
+            unset($queries[$index]);
+        }
+
+        return \array_merge(\array_values($queries), $additionalQueries);
+    }
+
+    private function relateDocuments(
+        Document $collection,
+        Document $relatedCollection,
+        string $key,
+        Document $document,
+        Document $relation,
+        RelationType $relationType,
+        bool $twoWay,
+        string $twoWayKey,
+        RelationSide $side,
+    ): string {
+        switch ($relationType) {
+            case RelationType::OneToOne:
+                if ($twoWay) {
+                    $relation->setAttribute($twoWayKey, $document->getId());
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    $relation->setAttribute($twoWayKey, $document->getId());
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
+                    $relation->setAttribute($twoWayKey, $document->getId());
+                }
+                break;
+        }
+
+        $related = $this->db->getDocument($relatedCollection->getId(), $relation->getId());
+
+        if ($related->isEmpty()) {
+            if (! isset($relation[Document::PERMISSIONS])) {
+                $relation->setAttribute(Document::PERMISSIONS, $document->getPermissions());
+            }
+
+            $related = $this->db->createDocument($relatedCollection->getId(), $relation);
+        } elseif ($related->getAttributes() != $relation->getAttributes()) {
+            foreach ($relation->getAttributes() as $attribute => $value) {
+                $related->setAttribute($attribute, $value);
+            }
+
+            $related = $this->db->updateDocument($relatedCollection->getId(), $related->getId(), $related);
+        }
+
+        if ($relationType === RelationType::ManyToMany) {
+            $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+            $this->db->createDocument($junction, new Document([
+                $key => $related->getId(),
+                $twoWayKey => $document->getId(),
+                Document::PERMISSIONS => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ]));
+        }
+
+        return $related->getId();
+    }
+
+    private function relateDocumentsById(
+        Document $collection,
+        Document $relatedCollection,
+        string $key,
+        string $documentId,
+        string $relationId,
+        RelationType $relationType,
+        bool $twoWay,
+        string $twoWayKey,
+        RelationSide $side,
+    ): void {
+        $related = $this->db->skipRelationships(fn () => $this->db->getDocument($relatedCollection->getId(), $relationId));
+
+        if ($related->isEmpty() && $this->checkExist) {
+            return;
+        }
+
+        switch ($relationType) {
+            case RelationType::OneToOne:
+                if ($twoWay) {
+                    $related->setAttribute($twoWayKey, $documentId);
+                    $this->db->skipRelationships(fn () => $this->db->updateDocument($relatedCollection->getId(), $relationId, $related));
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Parent) {
+                    $related->setAttribute($twoWayKey, $documentId);
+                    $this->db->skipRelationships(fn () => $this->db->updateDocument($relatedCollection->getId(), $relationId, $related));
+                }
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Child) {
+                    $related->setAttribute($twoWayKey, $documentId);
+                    $this->db->skipRelationships(fn () => $this->db->updateDocument($relatedCollection->getId(), $relationId, $related));
+                }
+                break;
+            case RelationType::ManyToMany:
+                $this->db->purgeCachedDocument($relatedCollection->getId(), $relationId);
+
+                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                $this->db->skipRelationships(fn () => $this->db->createDocument($junction, new Document([
+                    $key => $relationId,
+                    $twoWayKey => $documentId,
+                    Document::PERMISSIONS => [
+                        Permission::read(Role::any()),
+                        Permission::update(Role::any()),
+                        Permission::delete(Role::any()),
+                    ],
+                ])));
+                break;
+        }
+    }
+
+    private function getJunctionCollection(Document $collection, Document $relatedCollection, RelationSide $side): string
+    {
+        return $side === RelationSide::Parent
+            ? '_'.$collection->getSequence().'_'.$relatedCollection->getSequence()
+            : '_'.$relatedCollection->getSequence().'_'.$collection->getSequence();
+    }
+
+    /**
+     * @param  array<string>  $existingIds
+     * @return array<string|Document>
+     */
+    private function applyRelationshipOperator(Operator $operator, array $existingIds): array
+    {
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+
+        $valueIds = \array_filter(\array_map(fn ($item) => $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null), $values));
+
+        switch ($method) {
+            case OperatorType::ArrayAppend:
+                return \array_values(\array_merge($existingIds, $valueIds));
+
+            case OperatorType::ArrayPrepend:
+                return \array_values(\array_merge($valueIds, $existingIds));
+
+            case OperatorType::ArrayInsert:
+                /** @var int $index */
+                $index = $values[0] ?? 0;
+                $item = $values[1] ?? null;
+                $itemId = $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null);
+                if ($itemId !== null) {
+                    \array_splice($existingIds, (int) $index, 0, [$itemId]);
+                }
+
+                return \array_values($existingIds);
+
+            case OperatorType::ArrayRemove:
+                $toRemove = $values[0] ?? null;
+                if (\is_array($toRemove)) {
+                    $toRemoveIds = \array_filter(\array_map(fn ($item) => $item instanceof Document ? $item->getId() : (\is_string($item) ? $item : null), $toRemove));
+
+                    return \array_values(\array_diff($existingIds, $toRemoveIds));
+                }
+                $toRemoveId = $toRemove instanceof Document ? $toRemove->getId() : (\is_string($toRemove) ? $toRemove : null);
+                if ($toRemoveId !== null) {
+                    return \array_values(\array_diff($existingIds, [$toRemoveId]));
+                }
+
+                return $existingIds;
+
+            case OperatorType::ArrayUnique:
+                return \array_values(\array_unique($existingIds));
+
+            case OperatorType::ArrayIntersect:
+                return \array_values(\array_intersect($existingIds, $valueIds));
+
+            case OperatorType::ArrayDiff:
+                return \array_values(\array_diff($existingIds, $valueIds));
+
+            default:
+                return $existingIds;
+        }
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    private function populateSingleRelationshipBatch(array $documents, RelationshipVO $relationship, array $queries): array
+    {
+        return match ($relationship->type) {
+            RelationType::OneToOne => $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries),
+            RelationType::OneToMany => $this->populateOneToManyRelationshipsBatch($documents, $relationship, $queries),
+            RelationType::ManyToOne => $this->populateManyToOneRelationshipsBatch($documents, $relationship, $queries),
+            RelationType::ManyToMany => $this->populateManyToManyRelationshipsBatch($documents, $relationship, $queries),
+        };
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    private function populateOneToOneRelationshipsBatch(array $documents, RelationshipVO $relationship, array $queries): array
+    {
+        $key = $relationship->key;
+        $relatedCollection = $this->db->getCollection($relationship->relatedCollection);
+
+        $relatedIds = [];
+        $documentsByRelatedId = [];
+
+        foreach ($documents as $document) {
+            $value = $document->getAttribute($key);
+            if ($value !== null) {
+                if ($value instanceof Document) {
+                    continue;
+                }
+
+                /** @var string $relId */
+                $relId = $value;
+                $relatedIds[] = $relId;
+                if (! isset($documentsByRelatedId[$relId])) {
+                    $documentsByRelatedId[$relId] = [];
+                }
+                $documentsByRelatedId[$relId][] = $document;
+            }
+        }
+
+        if (empty($relatedIds)) {
+            return [];
+        }
+
+        $selectQueries = [];
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                $selectQueries[] = $query;
+            } else {
+                $otherQueries[] = $query;
+            }
+        }
+
+        /** @var array<string> $uniqueRelatedIds */
+        $uniqueRelatedIds = \array_unique($relatedIds);
+        $relatedDocuments = [];
+
+        $chunks = \array_chunk($uniqueRelatedIds, $this->relationQueryChunkSize());
+
+        if (\count($chunks) > 1) {
+            $collectionId = $relatedCollection->getId();
+            $tasks = \array_map(
+                fn (array $chunk) => fn () => $this->db->find($collectionId, [
+                    Query::equal(Document::ID, $chunk),
+                    Query::limit(PHP_INT_MAX),
+                    ...$otherQueries,
+                ]),
+                $chunks
+            );
+
+            /** @var array<array<Document>> $chunkResults */
+            $chunkResults = Promise::map($tasks)->await();
+
+            foreach ($chunkResults as $chunkDocs) {
+                \array_push($relatedDocuments, ...$chunkDocs);
+            }
+        } elseif (\count($chunks) === 1) {
+            $relatedDocuments = $this->db->find($relatedCollection->getId(), [
+                Query::equal(Document::ID, $chunks[0]),
+                Query::limit(PHP_INT_MAX),
+                ...$otherQueries,
+            ]);
+        }
+
+        $relatedById = [];
+        foreach ($relatedDocuments as $related) {
+            $relatedById[$related->getId()] = $related;
+        }
+
+        $this->db->applySelectFiltersToDocuments($relatedDocuments, $selectQueries);
+
+        foreach ($documentsByRelatedId as $relatedId => $docs) {
+            if (isset($relatedById[$relatedId])) {
+                foreach ($docs as $document) {
+                    $document->setAttribute($key, $relatedById[$relatedId]);
+                }
+            } else {
+                foreach ($docs as $document) {
+                    $document->setAttribute($key, new Document());
+                }
+            }
+        }
+
+        return $relatedDocuments;
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    private function populateOneToManyRelationshipsBatch(array $documents, RelationshipVO $relationship, array $queries): array
+    {
+        $key = $relationship->key;
+        $twoWay = $relationship->twoWay;
+        $twoWayKey = $relationship->twoWayKey;
+        $side = $relationship->side;
+        $relatedCollection = $this->db->getCollection($relationship->relatedCollection);
+
+        if ($side === RelationSide::Child) {
+            if (! $twoWay) {
+                foreach ($documents as $document) {
+                    $document->removeAttribute($key);
+                }
+
+                return [];
+            }
+
+            return $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries);
+        }
+
+        $parentIds = [];
+        foreach ($documents as $document) {
+            $parentId = $document->getId();
+            $parentIds[] = $parentId;
+        }
+
+        $parentIds = \array_unique($parentIds);
+
+        if (empty($parentIds)) {
+            return [];
+        }
+
+        $selectQueries = [];
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                $selectQueries[] = $query;
+            } else {
+                $otherQueries[] = $query;
+            }
+        }
+
+        $relatedDocuments = [];
+
+        $chunks = \array_chunk($parentIds, $this->relationQueryChunkSize());
+
+        if (\count($chunks) > 1) {
+            $collectionId = $relatedCollection->getId();
+            $tasks = \array_map(
+                fn (array $chunk) => fn () => $this->db->find($collectionId, [
+                    Query::equal($twoWayKey, $chunk),
+                    Query::limit(PHP_INT_MAX),
+                    ...$otherQueries,
+                ]),
+                $chunks
+            );
+
+            /** @var array<array<Document>> $chunkResults */
+            $chunkResults = Promise::map($tasks)->await();
+
+            foreach ($chunkResults as $chunkDocs) {
+                \array_push($relatedDocuments, ...$chunkDocs);
+            }
+        } elseif (\count($chunks) === 1) {
+            $relatedDocuments = $this->db->find($relatedCollection->getId(), [
+                Query::equal($twoWayKey, $chunks[0]),
+                Query::limit(PHP_INT_MAX),
+                ...$otherQueries,
+            ]);
+        }
+
+        $relatedByParentId = [];
+        foreach ($relatedDocuments as $related) {
+            $parentId = $related->getAttribute($twoWayKey);
+            if ($parentId instanceof Document) {
+                $parentKey = $parentId->getId();
+            } elseif (\is_string($parentId)) {
+                $parentKey = $parentId;
+            } else {
+                continue;
+            }
+
+            if (! isset($relatedByParentId[$parentKey])) {
+                $relatedByParentId[$parentKey] = [];
+            }
+            $relatedByParentId[$parentKey][] = $related;
+        }
+
+        $this->db->applySelectFiltersToDocuments($relatedDocuments, $selectQueries);
+
+        foreach ($documents as $document) {
+            $parentId = $document->getId();
+            $relatedDocs = $relatedByParentId[$parentId] ?? [];
+            $document->setAttribute($key, $relatedDocs);
+        }
+
+        return $relatedDocuments;
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    private function populateManyToOneRelationshipsBatch(array $documents, RelationshipVO $relationship, array $queries): array
+    {
+        $key = $relationship->key;
+        $twoWay = $relationship->twoWay;
+        $twoWayKey = $relationship->twoWayKey;
+        $side = $relationship->side;
+        $relatedCollection = $this->db->getCollection($relationship->relatedCollection);
+
+        if ($side === RelationSide::Parent) {
+            return $this->populateOneToOneRelationshipsBatch($documents, $relationship, $queries);
+        }
+
+        if (! $twoWay) {
+            foreach ($documents as $document) {
+                $document->removeAttribute($key);
+            }
+
+            return [];
+        }
+
+        $childIds = [];
+        foreach ($documents as $document) {
+            $childId = $document->getId();
+            $childIds[] = $childId;
+        }
+
+        $childIds = array_unique($childIds);
+
+        if (empty($childIds)) {
+            return [];
+        }
+
+        $selectQueries = [];
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                $selectQueries[] = $query;
+            } else {
+                $otherQueries[] = $query;
+            }
+        }
+
+        $relatedDocuments = [];
+
+        $chunks = \array_chunk($childIds, $this->relationQueryChunkSize());
+
+        if (\count($chunks) > 1) {
+            $collectionId = $relatedCollection->getId();
+            $tasks = \array_map(
+                fn (array $chunk) => fn () => $this->db->find($collectionId, [
+                    Query::equal($twoWayKey, $chunk),
+                    Query::limit(PHP_INT_MAX),
+                    ...$otherQueries,
+                ]),
+                $chunks
+            );
+
+            /** @var array<array<Document>> $chunkResults */
+            $chunkResults = Promise::map($tasks)->await();
+
+            foreach ($chunkResults as $chunkDocs) {
+                \array_push($relatedDocuments, ...$chunkDocs);
+            }
+        } elseif (\count($chunks) === 1) {
+            $relatedDocuments = $this->db->find($relatedCollection->getId(), [
+                Query::equal($twoWayKey, $chunks[0]),
+                Query::limit(PHP_INT_MAX),
+                ...$otherQueries,
+            ]);
+        }
+
+        $relatedByChildId = [];
+        foreach ($relatedDocuments as $related) {
+            $childId = $related->getAttribute($twoWayKey);
+            if ($childId instanceof Document) {
+                $childKey = $childId->getId();
+            } elseif (\is_string($childId)) {
+                $childKey = $childId;
+            } else {
+                continue;
+            }
+
+            if (! isset($relatedByChildId[$childKey])) {
+                $relatedByChildId[$childKey] = [];
+            }
+            $relatedByChildId[$childKey][] = $related;
+        }
+
+        $this->db->applySelectFiltersToDocuments($relatedDocuments, $selectQueries);
+
+        foreach ($documents as $document) {
+            $childId = $document->getId();
+            $document->setAttribute($key, $relatedByChildId[$childId] ?? []);
+        }
+
+        return $relatedDocuments;
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    private function populateManyToManyRelationshipsBatch(array $documents, RelationshipVO $relationship, array $queries): array
+    {
+        $key = $relationship->key;
+        $twoWay = $relationship->twoWay;
+        $twoWayKey = $relationship->twoWayKey;
+        $side = $relationship->side;
+        $relatedCollection = $this->db->getCollection($relationship->relatedCollection);
+        $collection = $this->db->getCollection($relationship->collection);
+
+        if (! $twoWay && $side === RelationSide::Child) {
+            return [];
+        }
+
+        $documentIds = [];
+        foreach ($documents as $document) {
+            $documentId = $document->getId();
+            $documentIds[] = $documentId;
+        }
+
+        $documentIds = array_unique($documentIds);
+
+        if (empty($documentIds)) {
+            return [];
+        }
+
+        $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+        $junctions = [];
+
+        $junctionChunks = \array_chunk($documentIds, $this->relationQueryChunkSize());
+
+        if (\count($junctionChunks) > 1) {
+            $tasks = \array_map(
+                fn (array $chunk) => fn () => $this->db->skipRelationships(fn () => $this->db->find($junction, [
+                    Query::equal($twoWayKey, $chunk),
+                    Query::limit(PHP_INT_MAX),
+                ])),
+                $junctionChunks
+            );
+
+            /** @var array<array<Document>> $junctionChunkResults */
+            $junctionChunkResults = Promise::map($tasks)->await();
+
+            foreach ($junctionChunkResults as $chunkJunctions) {
+                \array_push($junctions, ...$chunkJunctions);
+            }
+        } elseif (\count($junctionChunks) === 1) {
+            $junctions = $this->db->skipRelationships(fn () => $this->db->find($junction, [
+                Query::equal($twoWayKey, $junctionChunks[0]),
+                Query::limit(PHP_INT_MAX),
+            ]));
+        }
+
+        /** @var array<string> $relatedIds */
+        $relatedIds = [];
+        /** @var array<string, array<string>> $junctionsByDocumentId */
+        $junctionsByDocumentId = [];
+
+        foreach ($junctions as $junctionDoc) {
+            $documentId = $junctionDoc->getAttribute($twoWayKey);
+            $relatedId = $junctionDoc->getAttribute($key);
+
+            if ($documentId !== null && $relatedId !== null) {
+                $documentIdStr = $documentId instanceof Document ? $documentId->getId() : (\is_string($documentId) ? $documentId : null);
+                $relatedIdStr = $relatedId instanceof Document ? $relatedId->getId() : (\is_string($relatedId) ? $relatedId : null);
+                if ($documentIdStr === null || $relatedIdStr === null) {
+                    continue;
+                }
+                if (! isset($junctionsByDocumentId[$documentIdStr])) {
+                    $junctionsByDocumentId[$documentIdStr] = [];
+                }
+                $junctionsByDocumentId[$documentIdStr][] = $relatedIdStr;
+                $relatedIds[] = $relatedIdStr;
+            }
+        }
+
+        $selectQueries = [];
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                $selectQueries[] = $query;
+            } else {
+                $otherQueries[] = $query;
+            }
+        }
+
+        $related = [];
+        $allRelatedDocs = [];
+        if (! empty($relatedIds)) {
+            $uniqueRelatedIds = array_unique($relatedIds);
+            $foundRelated = [];
+
+            $relatedChunks = \array_chunk($uniqueRelatedIds, $this->relationQueryChunkSize());
+
+            if (\count($relatedChunks) > 1) {
+                $relatedCollectionId = $relatedCollection->getId();
+                $tasks = \array_map(
+                    fn (array $chunk) => fn () => $this->db->find($relatedCollectionId, [
+                        Query::equal(Document::ID, $chunk),
+                        Query::limit(PHP_INT_MAX),
+                        ...$otherQueries,
+                    ]),
+                    $relatedChunks
+                );
+
+                /** @var array<array<Document>> $relatedChunkResults */
+                $relatedChunkResults = Promise::map($tasks)->await();
+
+                foreach ($relatedChunkResults as $chunkDocs) {
+                    \array_push($foundRelated, ...$chunkDocs);
+                }
+            } elseif (\count($relatedChunks) === 1) {
+                $foundRelated = $this->db->find($relatedCollection->getId(), [
+                    Query::equal(Document::ID, $relatedChunks[0]),
+                    Query::limit(PHP_INT_MAX),
+                    ...$otherQueries,
+                ]);
+            }
+
+            $allRelatedDocs = $foundRelated;
+
+            $relatedById = [];
+            foreach ($foundRelated as $doc) {
+                $relatedById[$doc->getId()] = $doc;
+            }
+
+            $this->db->applySelectFiltersToDocuments($allRelatedDocs, $selectQueries);
+
+            foreach ($junctionsByDocumentId as $documentId => $relatedDocIds) {
+                $documentRelated = [];
+                foreach ($relatedDocIds as $relatedId) {
+                    if (isset($relatedById[$relatedId])) {
+                        $documentRelated[] = $relatedById[$relatedId];
+                    }
+                }
+                $related[$documentId] = $documentRelated;
+            }
+        }
+
+        foreach ($documents as $document) {
+            $documentId = $document->getId();
+            $document->setAttribute($key, $related[$documentId] ?? []);
+        }
+
+        return $allRelatedDocs;
+    }
+
+    private function deleteRestrict(
+        Document $relatedCollection,
+        Document $document,
+        mixed $value,
+        RelationType $relationType,
+        bool $twoWay,
+        string $twoWayKey,
+        RelationSide $side
+    ): void {
+        if ($value instanceof Document && $value->isEmpty()) {
+            $value = null;
+        }
+
+        if (
+            ! empty($value)
+            && $relationType !== RelationType::ManyToOne
+            && $side === RelationSide::Parent
+        ) {
+            throw new RestrictedException('Cannot delete document because it has at least one related document.');
+        }
+
+        if (
+            $relationType === RelationType::OneToOne
+            && $side === RelationSide::Child
+            && ! $twoWay
+        ) {
+            $this->db->getAuthorization()->skip(function () use ($document, $relatedCollection, $twoWayKey) {
+                $related = $this->db->findOne($relatedCollection->getId(), [
+                    Query::select([Document::ID]),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                ]);
+
+                if ($related->isEmpty()) {
+                    return;
+                }
+
+                $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                    $relatedCollection->getId(),
+                    $related->getId(),
+                    new Document([
+                        $twoWayKey => null,
+                    ])
+                ));
+            });
+        }
+
+        if (
+            $relationType === RelationType::ManyToOne
+            && $side === RelationSide::Child
+        ) {
+            $related = $this->db->getAuthorization()->skip(fn () => $this->db->findOne($relatedCollection->getId(), [
+                Query::select([Document::ID]),
+                Query::equal($twoWayKey, [$document->getId()]),
+            ]));
+
+            if (! $related->isEmpty()) {
+                throw new RestrictedException('Cannot delete document because it has at least one related document.');
+            }
+        }
+    }
+
+    private function deleteSetNull(Document $collection, Document $relatedCollection, Document $document, mixed $value, RelationType $relationType, bool $twoWay, string $twoWayKey, RelationSide $side): void
+    {
+        switch ($relationType) {
+            case RelationType::OneToOne:
+                if (! $twoWay && $side === RelationSide::Parent) {
+                    break;
+                }
+
+                $this->db->getAuthorization()->skip(function () use ($document, $value, $relatedCollection, $twoWay, $twoWayKey) {
+                    if (! $twoWay) {
+                        $related = $this->db->findOne($relatedCollection->getId(), [
+                            Query::select([Document::ID]),
+                            Query::equal($twoWayKey, [$document->getId()]),
+                        ]);
+                    } else {
+                        if (empty($value)) {
+                            return;
+                        }
+                        /** @var Document $value */
+                        $related = $this->db->getDocument($relatedCollection->getId(), $value->getId(), [Query::select([Document::ID])]);
+                    }
+
+                    if ($related->isEmpty()) {
+                        return;
+                    }
+
+                    $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                        $relatedCollection->getId(),
+                        $related->getId(),
+                        new Document([
+                            $twoWayKey => null,
+                        ])
+                    ));
+                });
+                break;
+
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Child) {
+                    break;
+                }
+                /** @var array<Document> $value */
+                if (! empty($value)) {
+                    $relationIds = \array_map(fn (Document $relation) => $relation->getId(), $value);
+                    $this->db->getAuthorization()->skip(fn () => $this->db->skipRelationships(fn () => $this->db->updateDocuments(
+                        $relatedCollection->getId(),
+                        new Document([$twoWayKey => null]),
+                        [Query::equal(Document::ID, $relationIds)],
+                    )));
+                }
+                break;
+
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    break;
+                }
+
+                if (! $twoWay) {
+                    $value = $this->db->find($relatedCollection->getId(), [
+                        Query::select([Document::ID]),
+                        Query::equal($twoWayKey, [$document->getId()]),
+                        Query::limit(PHP_INT_MAX),
+                    ]);
+                }
+
+                /** @var array<Document> $value */
+                if (! empty($value)) {
+                    $relationIds = \array_map(fn (Document $relation) => $relation->getId(), $value);
+                    $this->db->getAuthorization()->skip(fn () => $this->db->skipRelationships(fn () => $this->db->updateDocuments(
+                        $relatedCollection->getId(),
+                        new Document([$twoWayKey => null]),
+                        [Query::equal(Document::ID, $relationIds)],
+                    )));
+                }
+                break;
+
+            case RelationType::ManyToMany:
+                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                $junctions = $this->db->find($junction, [
+                    Query::select([Document::ID]),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]);
+
+                if (! empty($junctions)) {
+                    $junctionIds = \array_map(fn (Document $junctionDoc) => $junctionDoc->getId(), $junctions);
+                    $this->db->skipRelationships(fn () => $this->db->deleteDocuments(
+                        $junction,
+                        [Query::equal(Document::ID, $junctionIds)],
+                    ));
+                }
+                break;
+        }
+    }
+
+    private function deleteCascade(Document $collection, Document $relatedCollection, Document $document, string $key, mixed $value, RelationType $relationType, string $twoWayKey, RelationSide $side, Document $relationship): void
+    {
+        switch ($relationType) {
+            case RelationType::OneToOne:
+                if ($value !== null) {
+                    $this->deleteStack[] = $relationship;
+
+                    $deleteId = ($value instanceof Document) ? $value->getId() : (\is_string($value) ? $value : null);
+                    if ($deleteId !== null) {
+                        $this->db->deleteDocument(
+                            $relatedCollection->getId(),
+                            $deleteId
+                        );
+                    }
+
+                    \array_pop($this->deleteStack);
+                }
+                break;
+            case RelationType::OneToMany:
+                if ($side === RelationSide::Child) {
+                    break;
+                }
+
+                $this->deleteStack[] = $relationship;
+
+                /** @var array<Document> $value */
+                if (! empty($value)) {
+                    $relationIds = \array_map(fn (Document $relation) => $relation->getId(), $value);
+                    $this->db->deleteDocuments(
+                        $relatedCollection->getId(),
+                        [Query::equal(Document::ID, $relationIds)],
+                    );
+                }
+
+                \array_pop($this->deleteStack);
+
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    break;
+                }
+
+                $value = $this->db->find($relatedCollection->getId(), [
+                    Query::select([Document::ID]),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]);
+
+                $this->deleteStack[] = $relationship;
+
+                if (! empty($value)) {
+                    $relationIds = \array_map(fn (Document $relation) => $relation->getId(), $value);
+                    $this->db->deleteDocuments(
+                        $relatedCollection->getId(),
+                        [Query::equal(Document::ID, $relationIds)],
+                    );
+                }
+
+                \array_pop($this->deleteStack);
+
+                break;
+            case RelationType::ManyToMany:
+                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                $junctions = $this->db->skipRelationships(fn () => $this->db->find($junction, [
+                    Query::select([Document::ID, $key]),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]));
+
+                $this->deleteStack[] = $relationship;
+
+                if (! empty($junctions)) {
+                    $junctionIds = [];
+                    $relatedIds = [];
+                    foreach ($junctions as $junctionDoc) {
+                        $junctionIds[] = $junctionDoc->getId();
+                        if ($side === RelationSide::Parent) {
+                            $relatedAttr = $junctionDoc->getAttribute($key);
+                            $relatedId = $relatedAttr instanceof Document ? $relatedAttr->getId() : (\is_string($relatedAttr) ? $relatedAttr : null);
+                            if ($relatedId !== null) {
+                                $relatedIds[] = $relatedId;
+                            }
+                        }
+                    }
+
+                    if (! empty($relatedIds)) {
+                        $this->db->deleteDocuments(
+                            $relatedCollection->getId(),
+                            [Query::equal(Document::ID, $relatedIds)],
+                        );
+                    }
+
+                    $this->db->deleteDocuments(
+                        $junction,
+                        [Query::equal(Document::ID, $junctionIds)],
+                    );
+                }
+
+                \array_pop($this->deleteStack);
+                break;
+        }
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<string>|null
+     */
+    private function processNestedRelationshipPath(string $startCollection, array $queries): ?array
+    {
+        $pathGroups = [];
+        foreach ($queries as $query) {
+            $attribute = $query->getAttribute();
+            if (\str_contains($attribute, '.')) {
+                $parts = \explode('.', $attribute);
+                $pathKey = \implode('.', \array_slice($parts, 0, -1));
+                if (! isset($pathGroups[$pathKey])) {
+                    $pathGroups[$pathKey] = [];
+                }
+                $pathGroups[$pathKey][] = [
+                    'method' => $query->getMethod(),
+                    'attribute' => \end($parts),
+                    'values' => $query->getValues(),
+                ];
+            }
+        }
+
+        /** @var array<string> $allMatchingIds */
+        $allMatchingIds = [];
+        foreach ($pathGroups as $path => $queryGroup) {
+            $pathParts = \explode('.', $path);
+            $currentCollection = $startCollection;
+            /** @var list<array{key: string, fromCollection: string, toCollection: string, relationType: RelationType, side: RelationSide, twoWayKey: string}> $relationshipChain */
+            $relationshipChain = [];
+
+            foreach ($pathParts as $relationshipKey) {
+                $collectionDoc = $this->db->silent(fn () => $this->db->getCollection($currentCollection));
+                /** @var array<Document|array<string, mixed>> $attributes */
+                $attributes = $collectionDoc->getAttribute('attributes', []);
+                $relationships = \array_filter(
+                    $attributes,
+                    function (mixed $attr): bool {
+                        if ($attr instanceof Document) {
+                            $type = $attr->getAttribute('type', '');
+                        } else {
+                            $type = $attr['type'] ?? '';
+                        }
+                        return \is_string($type) && ColumnType::tryFrom($type) === ColumnType::Relationship;
+                    }
+                );
+
+                /** @var array<string, mixed>|null $relationship */
+                $relationship = null;
+                foreach ($relationships as $rel) {
+                    /** @var array<string, mixed> $rel */
+                    if ($rel['key'] === $relationshipKey) {
+                        $relationship = $rel;
+                        break;
+                    }
+                }
+
+                if (! $relationship) {
+                    return null;
+                }
+
+                /** @var Document $relationship */
+                $nestedRel = RelationshipVO::fromArray(['collection' => $currentCollection] + $relationship->getArrayCopy());
+                $relationshipChain[] = [
+                    'key' => $relationshipKey,
+                    'fromCollection' => $currentCollection,
+                    'toCollection' => $nestedRel->relatedCollection,
+                    'relationType' => $nestedRel->type,
+                    'side' => $nestedRel->side,
+                    'twoWayKey' => $nestedRel->twoWayKey,
+                ];
+
+                $currentCollection = $nestedRel->relatedCollection;
+            }
+
+            $leafQueries = [];
+            foreach ($queryGroup as $q) {
+                $leafQueries[] = new Query($q['method'], $q['attribute'], $q['values']);
+            }
+
+            /** @var array<Document> $matchingDocs */
+            $matchingDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find(
+                $currentCollection,
+                \array_merge($leafQueries, [
+                    Query::select([Document::ID]),
+                    Query::limit(PHP_INT_MAX),
+                ])
+            )));
+
+            /** @var array<string> $matchingIds */
+            $matchingIds = \array_map(fn (Document $doc) => $doc->getId(), $matchingDocs);
+
+            if (empty($matchingIds)) {
+                return null;
+            }
+
+            for ($i = \count($relationshipChain) - 1; $i >= 0; $i--) {
+                $link = $relationshipChain[$i];
+                $relationType = $link['relationType'];
+                $side = $link['side'];
+                $linkKey = $link['key'];
+                $linkFromCollection = $link['fromCollection'];
+                $linkToCollection = $link['toCollection'];
+                $linkTwoWayKey = $link['twoWayKey'];
+
+                $needsReverseLookup = (
+                    ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) ||
+                    ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) ||
+                    ($relationType === RelationType::ManyToMany)
+                );
+
+                if ($needsReverseLookup) {
+                    if ($relationType === RelationType::ManyToMany) {
+                        $fromCollectionDoc = $this->db->silent(fn () => $this->db->getCollection($linkFromCollection));
+                        $toCollectionDoc = $this->db->silent(fn () => $this->db->getCollection($linkToCollection));
+                        $junction = $this->getJunctionCollection($fromCollectionDoc, $toCollectionDoc, $side);
+
+                        /** @var array<Document> $junctionDocs */
+                        $junctionDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find($junction, [
+                            Query::equal($linkKey, $matchingIds),
+                            Query::limit(PHP_INT_MAX),
+                        ])));
+
+                        /** @var array<string> $parentIds */
+                        $parentIds = [];
+                        foreach ($junctionDocs as $jDoc) {
+                            $pIdRaw = $jDoc->getAttribute($linkTwoWayKey);
+                            $pId = $pIdRaw instanceof Document ? $pIdRaw->getId() : (\is_string($pIdRaw) ? $pIdRaw : null);
+                            if ($pId && ! \in_array($pId, $parentIds)) {
+                                $parentIds[] = $pId;
+                            }
+                        }
+                    } else {
+                        /** @var array<Document> $childDocs */
+                        $childDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find(
+                            $linkToCollection,
+                            [
+                                Query::equal(Document::ID, $matchingIds),
+                                Query::select([Document::ID, $linkTwoWayKey]),
+                                Query::limit(PHP_INT_MAX),
+                            ]
+                        )));
+
+                        /** @var array<string> $parentIds */
+                        $parentIds = [];
+                        foreach ($childDocs as $doc) {
+                            $parentValue = $doc->getAttribute($linkTwoWayKey);
+                            if (\is_array($parentValue)) {
+                                foreach ($parentValue as $pId) {
+                                    if ($pId instanceof Document) {
+                                        $pId = $pId->getId();
+                                    }
+                                    if (\is_string($pId) && $pId && ! \in_array($pId, $parentIds)) {
+                                        $parentIds[] = $pId;
+                                    }
+                                }
+                            } else {
+                                if ($parentValue instanceof Document) {
+                                    $parentValue = $parentValue->getId();
+                                }
+                                if (\is_string($parentValue) && $parentValue && ! \in_array($parentValue, $parentIds)) {
+                                    $parentIds[] = $parentValue;
+                                }
+                            }
+                        }
+                    }
+                    $matchingIds = $parentIds;
+                } else {
+                    /** @var array<Document> $parentDocs */
+                    $parentDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find(
+                        $linkFromCollection,
+                        [
+                            Query::equal($linkKey, $matchingIds),
+                            Query::select([Document::ID]),
+                            Query::limit(PHP_INT_MAX),
+                        ]
+                    )));
+                    $matchingIds = \array_map(fn (Document $doc) => $doc->getId(), $parentDocs);
+                }
+
+                if (empty($matchingIds)) {
+                    return null;
+                }
+            }
+
+            $allMatchingIds = \array_merge($allMatchingIds, $matchingIds);
+        }
+
+        return \array_unique($allMatchingIds);
+    }
+
+    /**
+     * @param  array<Query>  $relatedQueries
+     * @return array{attribute: string, ids: string[]}|null
+     */
+    private function resolveRelationshipGroupToIds(
+        RelationshipVO $relationship,
+        array $relatedQueries,
+        ?Document $collection = null,
+    ): ?array {
+        $relatedCollection = $relationship->relatedCollection;
+        $relationType = $relationship->type;
+        $side = $relationship->side;
+        $twoWayKey = $relationship->twoWayKey;
+        $relationshipKey = $relationship->key;
+
+        $hasNestedPaths = false;
+        foreach ($relatedQueries as $relatedQuery) {
+            if (\str_contains($relatedQuery->getAttribute(), '.')) {
+                $hasNestedPaths = true;
+                break;
+            }
+        }
+
+        if ($hasNestedPaths) {
+            $matchingIds = $this->processNestedRelationshipPath(
+                $relatedCollection,
+                $relatedQueries
+            );
+
+            if ($matchingIds === null || empty($matchingIds)) {
+                return null;
+            }
+
+            $relatedQueries = \array_values(\array_merge(
+                \array_filter($relatedQueries, fn (Query $q) => ! \str_contains($q->getAttribute(), '.')),
+                [Query::equal(Document::ID, $matchingIds)]
+            ));
+        }
+
+        $needsParentResolution = (
+            ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) ||
+            ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) ||
+            ($relationType === RelationType::ManyToMany)
+        );
+
+        if ($relationType === RelationType::ManyToMany && $needsParentResolution && $collection !== null) {
+            /** @var array<Document> $matchingDocs */
+            $matchingDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find(
+                $relatedCollection,
+                \array_merge($relatedQueries, [
+                    Query::select([Document::ID]),
+                    Query::limit(PHP_INT_MAX),
+                ])
+            )));
+
+            $matchingIds = \array_map(fn (Document $doc) => $doc->getId(), $matchingDocs);
+
+            if (empty($matchingIds)) {
+                return null;
+            }
+
+            /** @var Document $relatedCollectionDoc */
+            $relatedCollectionDoc = $this->db->silent(fn () => $this->db->getCollection($relatedCollection));
+            $junction = $this->getJunctionCollection($collection, $relatedCollectionDoc, $side);
+
+            /** @var array<Document> $junctionDocs */
+            $junctionDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find($junction, [
+                Query::equal($relationshipKey, $matchingIds),
+                Query::limit(PHP_INT_MAX),
+            ])));
+
+            /** @var array<string> $parentIds */
+            $parentIds = [];
+            foreach ($junctionDocs as $jDoc) {
+                $pIdRaw = $jDoc->getAttribute($twoWayKey);
+                $pId = $pIdRaw instanceof Document ? $pIdRaw->getId() : (\is_string($pIdRaw) ? $pIdRaw : null);
+                if ($pId && ! \in_array($pId, $parentIds)) {
+                    $parentIds[] = $pId;
+                }
+            }
+
+            return empty($parentIds) ? null : ['attribute' => Document::ID, 'ids' => $parentIds];
+        } elseif ($needsParentResolution) {
+            /** @var array<Document> $matchingDocs */
+            $matchingDocs = $this->db->silent(fn () => $this->db->find(
+                $relatedCollection,
+                \array_merge($relatedQueries, [
+                    Query::limit(PHP_INT_MAX),
+                ])
+            ));
+
+            /** @var array<string> $parentIds */
+            $parentIds = [];
+
+            foreach ($matchingDocs as $doc) {
+                $parentId = $doc->getAttribute($twoWayKey);
+
+                if (\is_array($parentId)) {
+                    foreach ($parentId as $id) {
+                        if ($id instanceof Document) {
+                            $id = $id->getId();
+                        }
+                        if (\is_string($id) && $id && ! \in_array($id, $parentIds)) {
+                            $parentIds[] = $id;
+                        }
+                    }
+                } else {
+                    if ($parentId instanceof Document) {
+                        $parentId = $parentId->getId();
+                    }
+                    if (\is_string($parentId) && $parentId && ! \in_array($parentId, $parentIds)) {
+                        $parentIds[] = $parentId;
+                    }
+                }
+            }
+
+            return empty($parentIds) ? null : ['attribute' => Document::ID, 'ids' => $parentIds];
+        } else {
+            /** @var array<Document> $matchingDocs */
+            $matchingDocs = $this->db->silent(fn () => $this->db->skipRelationships(fn () => $this->db->find(
+                $relatedCollection,
+                \array_merge($relatedQueries, [
+                    Query::select([Document::ID]),
+                    Query::limit(PHP_INT_MAX),
+                ])
+            )));
+
+            /** @var array<string> $matchingIds */
+            $matchingIds = \array_map(fn (Document $doc) => $doc->getId(), $matchingDocs);
+
+            return empty($matchingIds) ? null : ['attribute' => $relationshipKey, 'ids' => $matchingIds];
+        }
+    }
+}
diff --git a/src/Database/Hook/Tenancy.php b/src/Database/Hook/Tenancy.php
new file mode 100644
index 0000000000..7c3eea9e14
--- /dev/null
+++ b/src/Database/Hook/Tenancy.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Storage;
+
+/**
+ * Tenant hook that handles both read-side query filtering and write-side row decoration.
+ *
+ * On reads: The SQL adapter generates tenant isolation conditions when this hook is registered.
+ * On writes: Injects the tenant identifier into every row written to a shared table.
+ */
+class Tenancy extends Interceptor
+{
+    /**
+     * @param int|string $tenant The current tenant identifier
+     * @param string $column The column name used to store the tenant value
+     */
+    public function __construct(
+        private int|string $tenant,
+        private string $column = Storage::TENANT,
+    ) {
+    }
+
+    public function getTenant(): int|string
+    {
+        return $this->tenant;
+    }
+
+    public function decorateRow(array $row, array $metadata = []): array
+    {
+        $row[$this->column] = $metadata['tenant'] ?? $this->tenant;
+
+        return $row;
+    }
+}
diff --git a/src/Database/Hook/TenantFilter.php b/src/Database/Hook/TenantFilter.php
new file mode 100644
index 0000000000..9c9458dfda
--- /dev/null
+++ b/src/Database/Hook/TenantFilter.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Builder\JoinType;
+use Utopia\Query\Hook\Filter;
+use Utopia\Query\Hook\Join\Condition as JoinCondition;
+use Utopia\Query\Hook\Join\Filter as JoinFilter;
+use Utopia\Query\Hook\Join\Placement;
+
+/**
+ * SQL read hook that generates tenant isolation conditions for shared-table configurations.
+ */
+class TenantFilter implements Filter, JoinFilter
+{
+    /**
+     * @param int|string $tenant The current tenant identifier
+     * @param string $metadataCollection The metadata collection name; metadata tables allow NULL tenants
+     * @param string $collection The actual collection/table name being queried (not the alias)
+     * @param string $allowNullColumn When set, unmatched outer-join rows keep a NULL tenant
+     */
+    public function __construct(
+        private int|string $tenant,
+        private string $metadataCollection = '',
+        private string $collection = '',
+        private string $allowNullColumn = '',
+        private string $quoteChar = '`',
+    ) {
+    }
+
+    public function filter(string $table): Condition
+    {
+        $prefix = (!\str_contains($table, '.') && !\str_contains($table, '`')) ? "{$table}." : '';
+
+        $name = $this->collection !== '' ? $this->collection : $table;
+
+        // A metadata row may be tenantless -- a shared pool creates its system
+        // collections once, with no tenant, so every tenant on the pool reads
+        // the one definition. Its permission rows carry the document's tenant,
+        // so they are tenantless too, and the side table has to be recognised
+        // as metadata or a write holding a project's tenant filters them out:
+        // the rows are matched for neither read nor delete, and revoking a
+        // permission on a shared definition silently does nothing.
+        $isMetadata = ! empty($this->metadataCollection)
+            && ($name === $this->metadataCollection
+                || $name === Storage::permissionsTable($this->metadataCollection));
+
+        if ($isMetadata) {
+            $condition = new Condition("({$prefix}".Storage::TENANT." IN (?) OR {$prefix}".Storage::TENANT." IS NULL)", [$this->tenant]);
+        } else {
+            $condition = new Condition("{$prefix}".Storage::TENANT." IN (?)", [$this->tenant]);
+        }
+
+        if ($this->allowNullColumn === '') {
+            return $condition;
+        }
+
+        return AllowNullColumn::wrap($condition, $this->allowNullColumn, $this->quoteChar);
+    }
+
+    public function filterJoin(string $table, JoinType $joinType): ?JoinCondition
+    {
+        $condition = new Condition("{$table}.".Storage::TENANT." IN (?)", [$this->tenant]);
+
+        if ($joinType === JoinType::FullOuter) {
+            $condition = AllowNullColumn::wrap(
+                $condition,
+                $table.'.'.Storage::TENANT,
+                $this->quoteChar,
+            );
+        }
+
+        $placement = match ($joinType) {
+            JoinType::Left => Placement::On,
+            default => Placement::Where,
+        };
+
+        return new JoinCondition($condition, $placement);
+    }
+}
diff --git a/src/Database/Hook/Transform.php b/src/Database/Hook/Transform.php
new file mode 100644
index 0000000000..1271b00aa5
--- /dev/null
+++ b/src/Database/Hook/Transform.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Event;
+use Utopia\Query\Hook;
+
+/**
+ * Hook for transforming SQL queries before execution.
+ *
+ * Implementations receive the raw SQL string and return a modified version.
+ * Registered via Database::addHook() and applied in the adapter's
+ * executeResult() path.
+ */
+interface Transform extends Hook
+{
+    /**
+     * Transform a raw SQL query string before it is executed.
+     *
+     * @param Event $event The database event type triggering the query
+     * @param string $query The raw SQL query string
+     * @return string The transformed SQL query string
+     */
+    public function transform(Event $event, string $query): string;
+}
diff --git a/src/Database/Hook/Write.php b/src/Database/Hook/Write.php
new file mode 100644
index 0000000000..bfe71319fd
--- /dev/null
+++ b/src/Database/Hook/Write.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Utopia\Database\Change;
+use Utopia\Database\Document;
+use Utopia\Query\Hook\Write as BaseWrite;
+
+/**
+ * Write hook interface for intercepting document write operations.
+ *
+ * Implementations can decorate rows before insertion and perform side effects
+ * (e.g. permission or tenant management) after document CRUD operations.
+ */
+interface Write extends BaseWrite
+{
+    /**
+     * Decorate a row before it's written to any table (document or side table).
+     * Database-level adapter calls this with document metadata extracted from Document objects.
+     *
+     * @param  array<string, mixed>  $row
+     * @param  array<string, mixed>  $metadata
+     * @return array<string, mixed>
+     */
+    public function decorateRow(array $row, array $metadata = []): array;
+
+    /**
+     * Execute after documents are created (e.g. insert permission rows).
+     *
+     * @param  array<Document>  $documents
+     */
+    public function afterDocumentCreate(string $collection, array $documents, WriteContext $context): void;
+
+    /**
+     * Execute after a document is updated (e.g. sync permission rows).
+     */
+    public function afterDocumentUpdate(string $collection, Document $document, bool $skipPermissions, WriteContext $context): void;
+
+    /**
+     * Execute after documents are updated in batch (e.g. sync permission rows).
+     *
+     * @param  array<Document>  $documents
+     */
+    public function afterDocumentBatchUpdate(string $collection, Document $updates, array $documents, WriteContext $context): void;
+
+    /**
+     * Execute after documents are upserted (e.g. sync permission rows from old→new diffs).
+     *
+     * @param  array<Change>  $changes
+     */
+    public function afterDocumentUpsert(string $collection, array $changes, WriteContext $context): void;
+
+    /**
+     * Execute after documents are deleted (e.g. clean up permission rows).
+     *
+     * @param  list<string>  $documentIds
+     */
+    public function afterDocumentDelete(string $collection, array $documentIds, WriteContext $context): void;
+}
diff --git a/src/Database/Hook/WriteContext.php b/src/Database/Hook/WriteContext.php
new file mode 100644
index 0000000000..b811a073cc
--- /dev/null
+++ b/src/Database/Hook/WriteContext.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Closure;
+use PDOStatement;
+use Swoole\Database\PDOStatementProxy;
+use Utopia\Database\Event;
+use Utopia\Database\PDOStatement as DatabasePDOStatement;
+use Utopia\Query\Builder\Statement;
+
+/**
+ * Immutable context object passed to Write hooks, providing closures for query building and execution.
+ */
+readonly class WriteContext
+{
+    /**
+     * @param  Closure(string, string=): \Utopia\Query\Builder\SQL  $newBuilder  Create a query builder for a table (with read-side hooks like TenantFilter already applied)
+     * @param  Closure(Statement, Event=): (PDOStatement|DatabasePDOStatement|PDOStatementProxy)  $executeResult  Prepare a Statement with optional event trigger, returns PDO statement
+     * @param  Closure(PDOStatement|DatabasePDOStatement|PDOStatementProxy): bool  $execute  Execute a prepared statement
+     * @param  Closure(array<string, mixed>, array<string, mixed>): array<string, mixed>  $decorateRow  Apply all write hooks' decorateRow to a row
+     * @param  Closure(): \Utopia\Query\Builder\SQL  $createBuilder  Create a raw builder (no hooks, no table)
+     * @param  Closure(string): string  $getTableRaw  Get the raw SQL table name with namespace prefix
+     * @param  bool  $skipDuplicates  Whether duplicate-key errors should be swallowed by this write
+     * @param  string|null  $lookupId  The document id used to load/update, when it may differ in casing from getId()
+     */
+    public function __construct(
+        public Closure $newBuilder,
+        public Closure $executeResult,
+        public Closure $execute,
+        public Closure $decorateRow,
+        public Closure $createBuilder,
+        public Closure $getTableRaw,
+        public bool $skipDuplicates = false,
+        public ?string $lookupId = null,
+    ) {
+    }
+}
diff --git a/src/Database/Index.php b/src/Database/Index.php
new file mode 100644
index 0000000000..f2bf4b20b7
--- /dev/null
+++ b/src/Database/Index.php
@@ -0,0 +1,585 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
+
+/**
+ * Represents a database index with its type, target attributes, and configuration.
+ *
+ * @property string $key
+ * @property IndexType $type
+ * @property array<string> $attributes
+ * @property array<int|null> $lengths
+ * @property array<Order|null> $orders
+ * @property int $ttl
+ */
+class Index extends Document
+{
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public function __construct(
+        string $key,
+        IndexType $type,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ) {
+        parent::__construct([
+            self::ID => $key,
+            'key' => $key,
+            'type' => $type->value,
+            'attributes' => $attributes,
+            'lengths' => $lengths,
+            'orders' => self::encodeOrders($orders),
+            'ttl' => $ttl,
+        ]);
+    }
+
+    /**
+     * @return (
+     *     $name is 'key' ? string :
+     *     $name is 'type' ? IndexType :
+     *     $name is 'attributes' ? array<string> :
+     *     $name is 'lengths' ? array<int|null> :
+     *     $name is 'orders' ? array<Order|null> :
+     *     $name is 'ttl' ? int :
+     *     mixed
+     * )
+     */
+    public function __get(string $name): mixed
+    {
+        switch ($name) {
+            case 'key':
+                /** @var string $key */
+                $key = $this->getAttribute('key', $this->getId());
+
+                return $key;
+            case 'type':
+                $type = $this->getAttribute('type', IndexType::Key->value);
+                if ($type instanceof IndexType) {
+                    return $type;
+                }
+
+                return IndexType::from(\is_string($type) ? $type : IndexType::Key->value);
+            case 'attributes':
+                $attributes = $this->getAttribute('attributes', []);
+                if (! \is_array($attributes)) {
+                    return [];
+                }
+                /** @var array<string> $attributes */
+
+                return $attributes;
+            case 'lengths':
+                $lengths = $this->getAttribute('lengths', []);
+                if (! \is_array($lengths)) {
+                    return [];
+                }
+                /** @var array<int|null> $lengths */
+
+                return $lengths;
+            case 'orders':
+                $stored = $this->getAttribute('orders', []);
+
+                return self::decodeOrders(\is_array($stored) ? $stored : []);
+            case 'ttl':
+                /** @var int $ttl */
+                $ttl = $this->getAttribute('ttl', 1);
+
+                return $ttl;
+            default:
+                return $this->getAttribute($name);
+        }
+    }
+
+    public function __set(string $name, mixed $value): void
+    {
+        match ($name) {
+            'key' => $this->setAttribute('key', $value)->setAttribute(self::ID, $value),
+            'type' => $this->setAttribute('type', $value instanceof IndexType ? $value->value : $value),
+            'attributes' => $this->setAttribute('attributes', $value),
+            'lengths' => $this->setAttribute('lengths', $value),
+            'orders' => $this->setAttribute('orders', self::encodeOrders(\is_array($value) ? $value : [])),
+            'ttl' => $this->setAttribute('ttl', $value),
+            default => $this->setAttribute($name, $value),
+        };
+    }
+
+    public function __isset(string $name): bool
+    {
+        return match ($name) {
+            'key', 'type', 'attributes', 'lengths', 'orders', 'ttl' => true,
+            default => $this->offsetExists($name),
+        };
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function key(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Key,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function index(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Index,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function unique(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Unique,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function fullText(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Fulltext,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function spatial(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Spatial,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function object(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Object,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function hnswEuclidean(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::HnswEuclidean,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function hnswCosine(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::HnswCosine,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function hnswDot(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::HnswDot,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function trigram(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Trigram,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    public static function ttl(
+        string $key,
+        array $attributes = [],
+        array $lengths = [],
+        array $orders = [],
+        int $ttl = 1,
+    ): self {
+        return new self(
+            key: $key,
+            type: IndexType::Ttl,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * Convert this index to a Document representation.
+     *
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        return new Document([
+            Document::ID => ID::custom($this->key),
+            'key' => $this->key,
+            'type' => $this->type->value,
+            'attributes' => $this->attributes,
+            'lengths' => $this->lengths,
+            'orders' => $this->getAttribute('orders', []),
+            'ttl' => $this->ttl,
+        ]);
+    }
+
+    /**
+     * Create from an associative array (used by collection config files).
+     *
+     * @param  array<string, mixed>  $data
+     */
+    public static function fromArray(array $data): self
+    {
+        /** @var IndexType|string $type */
+        $type = $data['type'] ?? 'key';
+        /** @var string $key */
+        $key = $data[Document::ID] ?? $data['key'] ?? '';
+        /** @var array<string> $attributes */
+        $attributes = $data['attributes'] ?? [];
+        /** @var array<int|null> $lengths */
+        $lengths = $data['lengths'] ?? [];
+        /** @var array<mixed> $orders */
+        $orders = $data['orders'] ?? [];
+        /** @var int $ttl */
+        $ttl = $data['ttl'] ?? 1;
+
+        return self::make(
+            key: $key,
+            type: $type instanceof IndexType ? $type : IndexType::from((string) $type),
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: self::decodeOrders($orders),
+            ttl: $ttl,
+        );
+    }
+
+    public static function fromDocument(Document $document): self
+    {
+        /** @var string $key */
+        $key = $document->getAttribute('key', $document->getId());
+        /** @var string $type */
+        $type = $document->getAttribute('type', IndexType::Key->value);
+        /** @var array<string> $attributes */
+        $attributes = $document->getAttribute('attributes', []);
+        /** @var array<int> $lengths */
+        $lengths = $document->getAttribute('lengths', []);
+        /** @var array<mixed> $orders */
+        $orders = $document->getAttribute('orders', []);
+        /** @var int $ttl */
+        $ttl = $document->getAttribute('ttl', 1);
+
+        return self::make(
+            key: $key,
+            type: IndexType::from($type),
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: self::decodeOrders($orders),
+            ttl: $ttl,
+        );
+    }
+
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<Order|null>  $orders
+     */
+    private static function make(
+        string $key,
+        IndexType $type,
+        array $attributes,
+        array $lengths,
+        array $orders,
+        int $ttl,
+    ): self {
+        return match ($type) {
+            IndexType::Key => self::key(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Index => self::index(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Unique => self::unique(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Fulltext => self::fullText(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Spatial => self::spatial(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Object => self::object(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::HnswEuclidean => self::hnswEuclidean(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::HnswCosine => self::hnswCosine(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::HnswDot => self::hnswDot(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Trigram => self::trigram(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+            IndexType::Ttl => self::ttl(
+                key: $key,
+                attributes: $attributes,
+                lengths: $lengths,
+                orders: $orders,
+                ttl: $ttl,
+            ),
+        };
+    }
+
+    public static function direction(?Order $order): string
+    {
+        return $order === null ? '' : $order->value;
+    }
+
+    /**
+     * @param  array<mixed>  $orders
+     * @return array<string|null>
+     */
+    private static function encodeOrders(array $orders): array
+    {
+        $encoded = [];
+
+        foreach ($orders as $order) {
+            if ($order instanceof Order) {
+                $encoded[] = $order->value;
+                continue;
+            }
+
+            if ($order === null) {
+                $encoded[] = null;
+                continue;
+            }
+
+            throw new \InvalidArgumentException('Index order must be Order or null');
+        }
+
+        return $encoded;
+    }
+
+    /**
+     * @param  array<mixed>  $orders
+     * @return array<Order|null>
+     */
+    private static function decodeOrders(array $orders): array
+    {
+        $decoded = [];
+
+        foreach ($orders as $order) {
+            if ($order instanceof Order || $order === null) {
+                $decoded[] = $order;
+                continue;
+            }
+
+            if (\is_string($order)) {
+                $decoded[] = Order::from($order);
+                continue;
+            }
+
+            throw new \InvalidArgumentException('Index order must be Order or null');
+        }
+
+        return $decoded;
+    }
+}
diff --git a/src/Database/Loading/BatchLoader.php b/src/Database/Loading/BatchLoader.php
new file mode 100644
index 0000000000..c0f2678fe3
--- /dev/null
+++ b/src/Database/Loading/BatchLoader.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Utopia\Database\Loading;
+
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+
+class BatchLoader
+{
+    /** @var array<string, array<string, array<LazyProxy>>> */
+    private array $pending = [];
+
+    private Database $db;
+
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+    }
+
+    public function register(LazyProxy $proxy, string $collection, string $id): void
+    {
+        $this->pending[$collection][$id][] = $proxy;
+    }
+
+    public function resolve(string $collection, string $id): ?Document
+    {
+        if (! isset($this->pending[$collection])) {
+            return null;
+        }
+
+        $ids = \array_keys($this->pending[$collection]);
+
+        if ($ids === []) {
+            return null;
+        }
+
+        $documents = $this->db->find($collection, [
+            Query::equal(Document::ID, $ids),
+            Query::limit(\count($ids)),
+        ]);
+
+        $byId = [];
+        foreach ($documents as $doc) {
+            $byId[$doc->getId()] = $doc;
+        }
+
+        foreach ($this->pending[$collection] as $pendingId => $proxies) {
+            $doc = $byId[$pendingId] ?? null;
+            foreach ($proxies as $proxy) {
+                $proxy->resolveWith($doc);
+            }
+        }
+
+        unset($this->pending[$collection]);
+
+        return $byId[$id] ?? null;
+    }
+}
diff --git a/src/Database/Loading/LazyProxy.php b/src/Database/Loading/LazyProxy.php
new file mode 100644
index 0000000000..3ed85c02ac
--- /dev/null
+++ b/src/Database/Loading/LazyProxy.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace Utopia\Database\Loading;
+
+use Utopia\Database\Document;
+
+class LazyProxy extends Document
+{
+    private bool $resolved = false;
+
+    private BatchLoader $batchLoader;
+
+    private string $targetCollection;
+
+    private string $targetId;
+
+    public function __construct(BatchLoader $batchLoader, string $targetCollection, string $targetId)
+    {
+        parent::__construct([Document::ID => $targetId]);
+        $this->batchLoader = $batchLoader;
+        $this->targetCollection = $targetCollection;
+        $this->targetId = $targetId;
+        $batchLoader->register($this, $targetCollection, $targetId);
+    }
+
+    public function resolveWith(?Document $document): void
+    {
+        $this->resolved = true;
+
+        if ($document !== null) {
+            foreach ($document->getArrayCopy() as $key => $value) {
+                parent::offsetSet($key, $value);
+            }
+        }
+    }
+
+    public function offsetGet(mixed $key): mixed
+    {
+        $this->ensureResolved();
+
+        return parent::offsetGet($key);
+    }
+
+    public function offsetExists(mixed $key): bool
+    {
+        $this->ensureResolved();
+
+        return parent::offsetExists($key);
+    }
+
+    public function getAttribute(string $name, mixed $default = null): mixed
+    {
+        $this->ensureResolved();
+
+        return parent::getAttribute($name, $default);
+    }
+
+    public function getArrayCopy(array $allow = [], array $disallow = []): array
+    {
+        $this->ensureResolved();
+
+        return parent::getArrayCopy($allow, $disallow);
+    }
+
+    public function isEmpty(): bool
+    {
+        $this->ensureResolved();
+
+        return parent::isEmpty();
+    }
+
+    public function isResolved(): bool
+    {
+        return $this->resolved;
+    }
+
+    private function ensureResolved(): void
+    {
+        if ($this->resolved) {
+            return;
+        }
+
+        $this->batchLoader->resolve($this->targetCollection, $this->targetId);
+        $this->resolved = true;
+    }
+}
diff --git a/src/Database/Loading/LoadingStrategy.php b/src/Database/Loading/LoadingStrategy.php
new file mode 100644
index 0000000000..e9614d3820
--- /dev/null
+++ b/src/Database/Loading/LoadingStrategy.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Utopia\Database\Loading;
+
+enum LoadingStrategy
+{
+    case Eager;
+    case Lazy;
+    case None;
+}
diff --git a/src/Database/Loading/NPlusOneDetector.php b/src/Database/Loading/NPlusOneDetector.php
new file mode 100644
index 0000000000..d36b970ff8
--- /dev/null
+++ b/src/Database/Loading/NPlusOneDetector.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace Utopia\Database\Loading;
+
+use Utopia\Database\Event;
+use Utopia\Database\Hook\Lifecycle;
+
+class NPlusOneDetector implements Lifecycle
+{
+    /** @var array<string, int> */
+    private array $queryCounts = [];
+
+    private int $threshold;
+
+    /** @var callable|null */
+    private $onDetected;
+
+    public function __construct(int $threshold = 5, ?callable $onDetected = null)
+    {
+        $this->threshold = $threshold;
+        $this->onDetected = $onDetected;
+    }
+
+    public function handle(Event $event, mixed $data): void
+    {
+        if ($event !== Event::DocumentFind && $event !== Event::DocumentRead) {
+            return;
+        }
+
+        $collection = '';
+        if (\is_string($data)) {
+            $collection = $data;
+        } elseif ($data instanceof \Utopia\Database\Document) {
+            $collection = $data->getCollection();
+        }
+
+        if ($collection === '') {
+            return;
+        }
+
+        $key = "{$event->value}:{$collection}";
+
+        if (! isset($this->queryCounts[$key])) {
+            $this->queryCounts[$key] = 0;
+        }
+
+        $this->queryCounts[$key]++;
+
+        if ($this->queryCounts[$key] === $this->threshold && $this->onDetected !== null) {
+            ($this->onDetected)($collection, $event, $this->queryCounts[$key]);
+        }
+    }
+
+    /**
+     * @return array<string, int>
+     */
+    public function getQueryCounts(): array
+    {
+        return $this->queryCounts;
+    }
+
+    /**
+     * @return array<string, int>
+     */
+    public function getViolations(): array
+    {
+        return \array_filter($this->queryCounts, fn (int $count) => $count >= $this->threshold);
+    }
+
+    public function reset(): void
+    {
+        $this->queryCounts = [];
+    }
+}
diff --git a/src/Database/Mirror.php b/src/Database/Mirror.php
index a0151cb92f..1e6082fb2a 100644
--- a/src/Database/Mirror.php
+++ b/src/Database/Mirror.php
@@ -2,15 +2,28 @@
 
 namespace Utopia\Database;
 
+use DateTime;
+use Throwable;
+use Utopia\Async\Promise;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Hook\Lifecycle;
+use Utopia\Database\Hook\Relationships;
+use Utopia\Database\Hook\Write;
 use Utopia\Database\Mirroring\Filter;
 use Utopia\Database\Validator\Authorization;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\Order;
 
+/**
+ * Wraps a source Database and replicates write operations to an optional destination Database.
+ */
 class Mirror extends Database
 {
     protected Database $source;
+
     protected ?Database $destination;
 
     /**
@@ -23,7 +36,7 @@ class Mirror extends Database
     /**
      * Callbacks to run when an error occurs on the destination database
      *
-     * @var array<callable(string, \Throwable): void>
+     * @var array<callable(string, Throwable): void>
      */
     protected array $errorCallbacks = [];
 
@@ -35,29 +48,59 @@ class Mirror extends Database
     ];
 
     /**
-     * @param Database $source
-     * @param ?Database $destination
-     * @param array<Filter> $filters
+     * @param  array<Filter>  $filters
      */
     public function __construct(
         Database $source,
         ?Database $destination = null,
         array $filters = [],
     ) {
+        $this->source = $source;
+        $this->destination = $destination;
+        $this->writeFilters = $filters;
         parent::__construct(
             $source->getAdapter(),
             $source->getCache()
         );
-        $this->source = $source;
-        $this->destination = $destination;
-        $this->writeFilters = $filters;
     }
 
+    /**
+     * Get the source database instance.
+     *
+     * @return Database
+     */
     public function getSource(): Database
     {
         return $this->source;
     }
 
+    /**
+     * Delegate validator caching to the source database so Mirror reuses the
+     * source's cache and inherits its invalidation. Mirror's own mutator
+     * overrides bypass the inherited traits, so its local
+     * `documentsValidatorCache` would otherwise go stale on schema changes.
+     */
+    protected function getDocumentsValidator(Document $collection): Validator\Queries\Documents
+    {
+        return $this->source->getDocumentsValidator($collection);
+    }
+
+    /**
+     * Delegate metadata reads to the source database. Mirror's schema mutator
+     * overrides forward writes to source and destination directly, so routing
+     * reads through the source keeps its view of attributes and relationships
+     * in lockstep with the authoritative database.
+     */
+    public function getCollection(string $id): Collection
+    {
+        return $this->source->getCollection($id);
+    }
+
+    /**
+     * Get the destination database instance, if configured.
+     *
+     * @return Database|null
+     */
     public function getDestination(): ?Database
     {
         return $this->destination;
@@ -72,8 +115,7 @@ public function getWriteFilters(): array
     }
 
     /**
-     * @param callable(string, \Throwable): void $callback
-     * @return void
+     * @param  callable(string, Throwable): void  $callback
      */
     public function onError(callable $callback): void
     {
@@ -81,55 +123,76 @@ public function onError(callable $callback): void
     }
 
     /**
-     * @param string $method
-     * @param array<mixed> $args
-     * @return mixed
+     * @param  array<mixed>  $args
      */
     protected function delegate(string $method, array $args = []): mixed
     {
-        $result = $this->source->{$method}(...$args);
-
         if ($this->destination === null) {
-            return $result;
+            return $this->source->{$method}(...$args);
         }
 
+        $sourceResult = $this->source->{$method}(...$args);
+
         try {
-            $result = $this->destination->{$method}(...$args);
-        } catch (\Throwable $err) {
+            $this->destination->{$method}(...$args);
+        } catch (Throwable $err) {
             $this->logError($method, $err);
         }
 
-        return $result;
+        return $sourceResult;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setDatabase(string $name): static
     {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        parent::setDatabase($name);
+        $this->source->setDatabase($name);
+        $this->destination?->setDatabase($name);
 
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setNamespace(string $namespace): static
     {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        parent::setNamespace($namespace);
+        $this->source->setNamespace($namespace);
+        $this->destination?->setNamespace($namespace);
 
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setSharedTables(bool $sharedTables): static
     {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        parent::setSharedTables($sharedTables);
+        $this->source->setSharedTables($sharedTables);
+        $this->destination?->setSharedTables($sharedTables);
 
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setTenant(int|string|null $tenant): static
     {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        parent::setTenant($tenant);
+        $this->source->setTenant($tenant);
+        $this->destination?->setTenant($tenant);
 
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setDropUnknownAttributes(bool $drop): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -139,6 +202,9 @@ public function setDropUnknownAttributes(bool $drop): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setPreserveDates(bool $preserve): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -148,6 +214,9 @@ public function setPreserveDates(bool $preserve): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setPreserveSequence(bool $preserve): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -157,6 +226,9 @@ public function setPreserveSequence(bool $preserve): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function enableValidation(): static
     {
         $this->delegate(__FUNCTION__);
@@ -166,6 +238,9 @@ public function enableValidation(): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function disableValidation(): static
     {
         $this->delegate(__FUNCTION__);
@@ -175,52 +250,118 @@ public function disableValidation(): static
         return $this;
     }
 
-    public function on(string $event, string $name, ?callable $callback): static
+    /**
+     * {@inheritdoc}
+     */
+    public function skipValidation(callable $callback): mixed
+    {
+        return parent::skipValidation(function () use ($callback) {
+            if ($this->destination === null) {
+                return $this->source->skipValidation($callback);
+            }
+
+            $destination = $this->destination;
+
+            return $this->source->skipValidation(
+                fn () => $destination->skipValidation($callback)
+            );
+        });
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addLifecycleHook(Lifecycle $hook): static
     {
-        $this->source->on($event, $name, $callback);
+        $this->source->addHook($hook);
 
         return $this;
     }
 
-    protected function trigger(string $event, mixed $args = null): void
+    protected function trigger(Event $event, mixed $data = null): void
     {
-        $this->source->trigger($event, $args);
+        $this->source->trigger($event, $data);
     }
 
-    public function silent(callable $callback, ?array $listeners = null): mixed
+    /**
+     * {@inheritdoc}
+     */
+    public function silent(callable $callback): mixed
     {
-        return $this->source->silent($callback, $listeners);
+        return $this->source->silent($callback);
     }
 
-    public function withRequestTimestamp(?\DateTime $requestTimestamp, callable $callback): mixed
+    /**
+     * {@inheritdoc}
+     */
+    public function withRequestTimestamp(?DateTime $requestTimestamp, callable $callback): mixed
     {
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function exists(?string $database = null, ?string $collection = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function create(?string $database = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        $result = $this->source->create($database);
+
+        if ($this->destination !== null) {
+            $this->destination->create($database);
+        }
+
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function delete(?string $database = null): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function createCollection(string $id, array $attributes = [], array $indexes = [], ?array $permissions = null, bool $documentSecurity = true): Document
+    /**
+     * {@inheritdoc}
+     */
+    public function listCollections(int $limit = 25, int $offset = 0): array
     {
-        $result = $this->source->createCollection(
-            $id,
-            $attributes,
-            $indexes,
-            $permissions,
-            $documentSecurity
-        );
+        $result = $this->silent(fn () => $this->source->find(self::METADATA, [
+            Query::notEqual(Document::ID, self::SOURCE_ONLY_COLLECTIONS),
+            Query::limit($limit),
+            Query::offset($offset),
+        ]));
+
+        $this->trigger(Event::CollectionList, $result);
+
+        $collections = [];
+        foreach ($result as $doc) {
+            $collections[] = $doc instanceof Collection ? $doc : Collection::fromArray($doc->getArrayCopy());
+        }
+
+        return $collections;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createCollection(Collection $collection): Collection
+    {
+        $collectionId = $collection->id;
+
+        $result = $this->source->createCollection($collection);
 
         if ($this->destination === null) {
             return $result;
@@ -228,37 +369,38 @@ public function createCollection(string $id, array $attributes = [], array $inde
 
         try {
             foreach ($this->writeFilters as $filter) {
-                $result = $filter->beforeCreateCollection(
+                $filtered = $filter->beforeCreateCollection(
                     source: $this->source,
                     destination: $this->destination,
-                    collectionId: $id,
+                    collectionId: $collectionId,
                     collection: $result,
                 );
+                if ($filtered !== null) {
+                    $result = $filtered;
+                }
             }
 
-            $this->destination->createCollection(
-                $id,
-                $attributes,
-                $indexes,
-                $permissions,
-                $documentSecurity
-            );
+            $this->destination->createCollection($collection);
 
-            $this->silent(function () use ($id) {
+            $this->silent(function () use ($collectionId) {
                 $this->createUpgrades();
 
                 $this->source->createDocument('upgrades', new Document([
-                    '$id' => $id,
-                    'collectionId' => $id,
-                    'status' => 'upgraded'
+                    Document::ID => $collectionId,
+                    'collectionId' => $collectionId,
+                    'status' => 'upgraded',
                 ]));
             });
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('createCollection', $err);
         }
-        return $result;
+
+        return $result instanceof Collection ? $result : Collection::fromArray($result->getArrayCopy());
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateCollection(string $id, array $permissions, bool $documentSecurity): Document
     {
         $result = $this->source->updateCollection($id, $permissions, $documentSecurity);
@@ -269,22 +411,28 @@ public function updateCollection(string $id, array $permissions, bool $documentS
 
         try {
             foreach ($this->writeFilters as $filter) {
-                $result = $filter->beforeUpdateCollection(
+                $filtered = $filter->beforeUpdateCollection(
                     source: $this->source,
                     destination: $this->destination,
                     collectionId: $id,
                     collection: $result,
                 );
+                if ($filtered !== null) {
+                    $result = $filtered;
+                }
             }
 
             $this->destination->updateCollection($id, $permissions, $documentSecurity);
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('updateCollection', $err);
         }
 
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteCollection(string $id): bool
     {
         $result = $this->source->deleteCollection($id);
@@ -303,77 +451,56 @@ public function deleteCollection(string $id): bool
                     collectionId: $id,
                 );
             }
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('deleteCollection', $err);
         }
 
         return $result;
     }
 
-    public function createAttribute(string $collection, string $id, string $type, int $size, bool $required, $default = null, bool $signed = true, bool $array = false, ?string $format = null, array $formatOptions = [], array $filters = []): bool
+    /**
+     * {@inheritdoc}
+     */
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        $result = $this->source->createAttribute(
-            $collection,
-            $id,
-            $type,
-            $size,
-            $required,
-            $default,
-            $signed,
-            $array,
-            $format,
-            $formatOptions,
-            $filters
-        );
+        $result = $this->source->createAttribute($collection, $attribute);
 
         if ($this->destination === null) {
             return $result;
         }
 
         try {
-            $document = new Document([
-                '$id' => $id,
-                'type' => $type,
-                'size' => $size,
-                'required' => $required,
-                'default' => $default,
-                'signed' => $signed,
-                'array' => $array,
-                'format' => $format,
-                'formatOptions' => $formatOptions,
-                'filters' => $filters,
-            ]);
+            // Round-trip through Document is required: Filter interface accepts/returns Document,
+            // so we must serialize to Document for filter processing, then deserialize back.
+            $document = $attribute->toDocument();
 
             foreach ($this->writeFilters as $filter) {
                 $document = $filter->beforeCreateAttribute(
                     source: $this->source,
                     destination: $this->destination,
                     collectionId: $collection,
-                    attributeId: $id,
+                    attributeId: $attribute->key,
                     attribute: $document,
                 );
+                if ($document === null) {
+                    break;
+                }
             }
 
-            $result = $this->destination->createAttribute(
-                $collection,
-                $document->getId(),
-                $document->getAttribute('type'),
-                $document->getAttribute('size'),
-                $document->getAttribute('required'),
-                $document->getAttribute('default'),
-                $document->getAttribute('signed'),
-                $document->getAttribute('array'),
-                $document->getAttribute('format'),
-                $document->getAttribute('formatOptions'),
-                $document->getAttribute('filters'),
-            );
-        } catch (\Throwable $err) {
+            if ($document !== null) {
+                $filteredAttribute = Attribute::fromDocument($document);
+                $result = $this->destination->createAttribute($collection, $filteredAttribute);
+            }
+        } catch (Throwable $err) {
             $this->logError('createAttribute', $err);
         }
 
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function createAttributes(string $collection, array $attributes): bool
     {
         $result = $this->source->createAttributes($collection, $attributes);
@@ -383,32 +510,47 @@ public function createAttributes(string $collection, array $attributes): bool
         }
 
         try {
-            foreach ($attributes as &$attribute) {
+            $filteredAttributes = [];
+            foreach ($attributes as $attribute) {
+                // Round-trip through Document is required: Filter interface accepts/returns Document,
+                // so we must serialize to Document for filter processing, then deserialize back.
+                $document = $attribute->toDocument();
+
                 foreach ($this->writeFilters as $filter) {
                     $document = $filter->beforeCreateAttribute(
                         source: $this->source,
                         destination: $this->destination,
                         collectionId: $collection,
-                        attributeId: $attribute['$id'],
-                        attribute: new Document($attribute),
+                        attributeId: $attribute->key,
+                        attribute: $document,
                     );
+                    if ($document === null) {
+                        break;
+                    }
+                }
 
-                    $attribute = $document->getArrayCopy();
+                if ($document !== null) {
+                    $filteredAttributes[] = Attribute::fromDocument($document);
                 }
             }
 
-            $result = $this->destination->createAttributes(
-                $collection,
-                $attributes,
-            );
-        } catch (\Throwable $err) {
+            if ($filteredAttributes !== []) {
+                $result = $this->destination->createAttributes(
+                    $collection,
+                    $filteredAttributes,
+                );
+            }
+        } catch (Throwable $err) {
             $this->logError('createAttributes', $err);
         }
 
         return $result;
     }
 
-    public function updateAttribute(string $collection, string $id, ?string $type = null, ?int $size = null, ?bool $required = null, mixed $default = null, ?bool $signed = null, ?bool $array = null, ?string $format = null, ?array $formatOptions = null, ?array $filters = null, ?string $newKey = null): Document
+    /**
+     * {@inheritdoc}
+     */
+    public function updateAttribute(string $collection, string $id, ColumnType|string|null $type = null, ?int $size = null, ?bool $required = null, mixed $default = null, ?bool $signed = null, ?bool $array = null, ?string $format = null, ?array $formatOptions = null, ?array $filters = null, ?string $newKey = null): Document
     {
         $document = $this->source->updateAttribute(
             $collection,
@@ -431,36 +573,44 @@ public function updateAttribute(string $collection, string $id, ?string $type =
 
         try {
             foreach ($this->writeFilters as $filter) {
-                $document = $filter->beforeUpdateAttribute(
+                $filtered = $filter->beforeUpdateAttribute(
                     source: $this->source,
                     destination: $this->destination,
                     collectionId: $collection,
                     attributeId: $id,
                     attribute: $document,
                 );
+                if ($filtered !== null) {
+                    $document = $filtered;
+                }
             }
 
+            $typedAttr = Attribute::fromDocument($document);
+
             $this->destination->updateAttribute(
                 $collection,
                 $id,
-                $document->getAttribute('type'),
-                $document->getAttribute('size'),
-                $document->getAttribute('required'),
-                $document->getAttribute('default'),
-                $document->getAttribute('signed'),
-                $document->getAttribute('array'),
-                $document->getAttribute('format'),
-                $document->getAttribute('formatOptions'),
-                $document->getAttribute('filters'),
+                $typedAttr->type,
+                $typedAttr->size,
+                $typedAttr->required,
+                $typedAttr->default,
+                $typedAttr->signed,
+                $typedAttr->array,
+                $typedAttr->format ?: null,
+                $typedAttr->formatOptions ?: null,
+                $typedAttr->filters ?: null,
                 $newKey,
             );
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('updateAttribute', $err);
         }
 
         return $document;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteAttribute(string $collection, string $id): bool
     {
         $result = $this->source->deleteAttribute($collection, $id);
@@ -480,56 +630,54 @@ public function deleteAttribute(string $collection, string $id): bool
             }
 
             $this->destination->deleteAttribute($collection, $id);
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('deleteAttribute', $err);
         }
 
         return $result;
     }
 
-    public function createIndex(string $collection, string $id, string $type, array $attributes, array $lengths = [], array $orders = [], int $ttl = 1): bool
+    /**
+     * {@inheritdoc}
+     */
+    public function createIndex(string $collection, Index $index): bool
     {
-        $result = $this->source->createIndex($collection, $id, $type, $attributes, $lengths, $orders, $ttl);
+        $result = $this->source->createIndex($collection, $index);
 
         if ($this->destination === null) {
             return $result;
         }
 
         try {
-            $document = new Document([
-                '$id' => $id,
-                'type' => $type,
-                'attributes' => $attributes,
-                'lengths' => $lengths,
-                'orders' => $orders,
-            ]);
+            // Round-trip through Document is required: Filter interface accepts/returns Document,
+            // so we must serialize to Document for filter processing, then deserialize back.
+            $document = $index->toDocument();
 
             foreach ($this->writeFilters as $filter) {
-                $document = $filter->beforeCreateIndex(
+                $filtered = $filter->beforeCreateIndex(
                     source: $this->source,
                     destination: $this->destination,
                     collectionId: $collection,
-                    indexId: $id,
+                    indexId: $index->key,
                     index: $document,
                 );
+                if ($filtered !== null) {
+                    $document = $filtered;
+                }
             }
 
-            $result = $this->destination->createIndex(
-                $collection,
-                $document->getId(),
-                $document->getAttribute('type'),
-                $document->getAttribute('attributes'),
-                $document->getAttribute('lengths'),
-                $document->getAttribute('orders'),
-                $document->getAttribute('ttl', 0)
-            );
-        } catch (\Throwable $err) {
+            $filteredIndex = Index::fromDocument($document);
+            $result = $this->destination->createIndex($collection, $filteredIndex);
+        } catch (Throwable $err) {
             $this->logError('createIndex', $err);
         }
 
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteIndex(string $collection, string $id): bool
     {
         $result = $this->source->deleteIndex($collection, $id);
@@ -549,13 +697,16 @@ public function deleteIndex(string $collection, string $id): bool
                     indexId: $id,
                 );
             }
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('deleteIndex', $err);
         }
 
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function createDocument(string $collection, Document $document): Document
     {
         $document = $this->source->createDocument($collection, $document);
@@ -596,13 +747,16 @@ public function createDocument(string $collection, Document $document): Document
                     document: $clone,
                 );
             }
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('createDocument', $err);
         }
 
         return $document;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function createDocuments(
         string $collection,
         array $documents,
@@ -632,55 +786,69 @@ public function createDocuments(
         // is mirrored, not that every row is backfilled, so a row that is a
         // duplicate on source may not yet exist on destination. In skipDuplicates
         // mode the destination runs its own INSERT IGNORE and decides per-row.
-        try {
-            $clones = [];
-            foreach ($documents as $document) {
-                $clone = clone $document;
-                foreach ($this->writeFilters as $filter) {
-                    $clone = $filter->beforeCreateDocument(
-                        source: $this->source,
-                        destination: $this->destination,
-                        collectionId: $collection,
-                        document: $clone,
-                    );
-                }
-                $clones[] = $clone;
-            }
+        $clones = [];
+        $destination = $this->destination;
 
-            if ($this->skipDuplicates) {
-                $this->destination->skipDuplicates(
-                    fn () => $this->destination->withPreserveDates(
-                        fn () => $this->destination->createDocuments($collection, $clones, $batchSize)
-                    )
-                );
-            } else {
-                $this->destination->withPreserveDates(
-                    fn () =>
-                    $this->destination->createDocuments(
-                        $collection,
-                        $clones,
-                        $batchSize,
-                    )
+        foreach ($documents as $document) {
+            $clone = clone $document;
+
+            foreach ($this->writeFilters as $filter) {
+                $clone = $filter->beforeCreateDocument(
+                    source: $this->source,
+                    destination: $destination,
+                    collectionId: $collection,
+                    document: $clone,
                 );
             }
 
-            foreach ($clones as $clone) {
-                foreach ($this->writeFilters as $filter) {
-                    $filter->afterCreateDocument(
-                        source: $this->source,
-                        destination: $this->destination,
-                        collectionId: $collection,
-                        document: $clone,
+            $clones[] = $clone;
+        }
+
+        $skipDuplicates = $this->skipDuplicates;
+
+        Promise::async(function () use ($destination, $collection, $clones, $batchSize, $skipDuplicates) {
+            try {
+                if ($skipDuplicates) {
+                    $destination->skipDuplicates(
+                        fn () => $destination->withPreserveDates(
+                            fn () => $destination->createDocuments(
+                                $collection,
+                                $clones,
+                                $batchSize,
+                            )
+                        )
                     );
+                } else {
+                    $destination->withPreserveDates(
+                        fn () => $destination->createDocuments(
+                            $collection,
+                            $clones,
+                            $batchSize,
+                        )
+                    );
+                }
+
+                foreach ($clones as $clone) {
+                    foreach ($this->writeFilters as $filter) {
+                        $filter->afterCreateDocument(
+                            source: $this->source,
+                            destination: $destination,
+                            collectionId: $collection,
+                            document: $clone,
+                        );
+                    }
                 }
+            } catch (Throwable $err) {
+                $this->logError('createDocuments', $err);
             }
-        } catch (\Throwable $err) {
-            $this->logError('createDocuments', $err);
-        }
+        });
 
         return $modified;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateDocument(string $collection, string $id, Document $document): Document
     {
         $document = $this->source->updateDocument($collection, $id, $document);
@@ -722,13 +890,16 @@ public function updateDocument(string $collection, string $id, Document $documen
                     document: $clone,
                 );
             }
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('updateDocument', $err);
         }
 
         return $document;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateDocuments(
         string $collection,
         Document $updates,
@@ -758,45 +929,50 @@ public function updateDocuments(
             return $modified;
         }
 
-        try {
-            $clone = clone $updates;
-
-            foreach ($this->writeFilters as $filter) {
-                $clone = $filter->beforeUpdateDocuments(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    updates: $clone,
-                    queries: $queries,
-                );
-            }
+        $clone = clone $updates;
+        $destination = $this->destination;
 
-            $this->destination->withPreserveDates(
-                fn () =>
-                $this->destination->updateDocuments(
-                    $collection,
-                    $clone,
-                    $queries,
-                    $batchSize,
-                )
+        foreach ($this->writeFilters as $filter) {
+            $clone = $filter->beforeUpdateDocuments(
+                source: $this->source,
+                destination: $destination,
+                collectionId: $collection,
+                updates: $clone,
+                queries: $queries,
             );
+        }
 
-            foreach ($this->writeFilters as $filter) {
-                $filter->afterUpdateDocuments(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    updates: $clone,
-                    queries: $queries,
+        Promise::async(function () use ($destination, $collection, $clone, $queries, $batchSize) {
+            try {
+                $destination->withPreserveDates(
+                    fn () => $destination->updateDocuments(
+                        $collection,
+                        $clone,
+                        $queries,
+                        $batchSize,
+                    )
                 );
+
+                foreach ($this->writeFilters as $filter) {
+                    $filter->afterUpdateDocuments(
+                        source: $this->source,
+                        destination: $destination,
+                        collectionId: $collection,
+                        updates: $clone,
+                        queries: $queries,
+                    );
+                }
+            } catch (Throwable $err) {
+                $this->logError('updateDocuments', $err);
             }
-        } catch (\Throwable $err) {
-            $this->logError('updateDocuments', $err);
-        }
+        });
 
         return $modified;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function upsertDocuments(
         string $collection,
         array $documents,
@@ -824,50 +1000,55 @@ public function upsertDocuments(
             return $modified;
         }
 
-        try {
-            $clones = [];
-
-            foreach ($documents as $document) {
-                $clone = clone $document;
+        $clones = [];
+        $destination = $this->destination;
 
-                foreach ($this->writeFilters as $filter) {
-                    $clone = $filter->beforeCreateOrUpdateDocument(
-                        source: $this->source,
-                        destination: $this->destination,
-                        collectionId: $collection,
-                        document: $clone,
-                    );
-                }
+        foreach ($documents as $document) {
+            $clone = clone $document;
 
-                $clones[] = $clone;
+            foreach ($this->writeFilters as $filter) {
+                $clone = $filter->beforeCreateOrUpdateDocument(
+                    source: $this->source,
+                    destination: $destination,
+                    collectionId: $collection,
+                    document: $clone,
+                );
             }
 
-            $this->destination->withPreserveDates(
-                fn () =>
-                $this->destination->upsertDocuments(
-                    $collection,
-                    $clones,
-                    $batchSize,
-                )
-            );
+            $clones[] = $clone;
+        }
 
-            foreach ($clones as $clone) {
-                foreach ($this->writeFilters as $filter) {
-                    $filter->afterCreateOrUpdateDocument(
-                        source: $this->source,
-                        destination: $this->destination,
-                        collectionId: $collection,
-                        document: $clone,
-                    );
+        Promise::async(function () use ($destination, $collection, $clones, $batchSize) {
+            try {
+                $destination->withPreserveDates(
+                    fn () => $destination->upsertDocuments(
+                        $collection,
+                        $clones,
+                        $batchSize,
+                    )
+                );
+
+                foreach ($clones as $clone) {
+                    foreach ($this->writeFilters as $filter) {
+                        $filter->afterCreateOrUpdateDocument(
+                            source: $this->source,
+                            destination: $destination,
+                            collectionId: $collection,
+                            document: $clone,
+                        );
+                    }
                 }
+            } catch (Throwable $err) {
+                $this->logError('upsertDocuments', $err);
             }
-        } catch (\Throwable $err) {
-            $this->logError('upsertDocuments', $err);
-        }
+        });
 
         return $modified;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteDocument(string $collection, string $id): bool
     {
         $result = $this->source->deleteDocument($collection, $id);
@@ -884,33 +1065,39 @@ public function deleteDocument(string $collection, string $id): bool
             return $result;
         }
 
-        try {
-            foreach ($this->writeFilters as $filter) {
-                $filter->beforeDeleteDocument(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    documentId: $id,
-                );
-            }
+        foreach ($this->writeFilters as $filter) {
+            $filter->beforeDeleteDocument(
+                source: $this->source,
+                destination: $this->destination,
+                collectionId: $collection,
+                documentId: $id,
+            );
+        }
 
-            $this->destination->deleteDocument($collection, $id);
+        $destination = $this->destination;
+        Promise::async(function () use ($destination, $collection, $id) {
+            try {
+                $destination->deleteDocument($collection, $id);
 
-            foreach ($this->writeFilters as $filter) {
-                $filter->afterDeleteDocument(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    documentId: $id,
-                );
+                foreach ($this->writeFilters as $filter) {
+                    $filter->afterDeleteDocument(
+                        source: $this->source,
+                        destination: $destination,
+                        collectionId: $collection,
+                        documentId: $id,
+                    );
+                }
+            } catch (Throwable $err) {
+                $this->logError('deleteDocument', $err);
             }
-        } catch (\Throwable $err) {
-            $this->logError('deleteDocument', $err);
-        }
+        });
 
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteDocuments(
         string $collection,
         array $queries = [],
@@ -938,112 +1125,170 @@ public function deleteDocuments(
             return $modified;
         }
 
-        try {
-            foreach ($this->writeFilters as $filter) {
-                $filter->beforeDeleteDocuments(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    queries: $queries,
-                );
-            }
-
-            $this->destination->deleteDocuments(
-                $collection,
-                $queries,
-                $batchSize,
+        foreach ($this->writeFilters as $filter) {
+            $filter->beforeDeleteDocuments(
+                source: $this->source,
+                destination: $this->destination,
+                collectionId: $collection,
+                queries: $queries,
             );
+        }
 
-            foreach ($this->writeFilters as $filter) {
-                $filter->afterDeleteDocuments(
-                    source: $this->source,
-                    destination: $this->destination,
-                    collectionId: $collection,
-                    queries: $queries,
+        $destination = $this->destination;
+        Promise::async(function () use ($destination, $collection, $queries, $batchSize) {
+            try {
+                $destination->deleteDocuments(
+                    $collection,
+                    $queries,
+                    $batchSize,
                 );
+
+                foreach ($this->writeFilters as $filter) {
+                    $filter->afterDeleteDocuments(
+                        source: $this->source,
+                        destination: $destination,
+                        collectionId: $collection,
+                        queries: $queries,
+                    );
+                }
+            } catch (Throwable $err) {
+                $this->logError('deleteDocuments', $err);
             }
-        } catch (\Throwable $err) {
-            $this->logError('deleteDocuments', $err);
-        }
+        });
 
         return $modified;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateAttributeRequired(string $collection, string $id, bool $required): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateAttributeFormat(string $collection, string $id, string $format): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateAttributeFormatOptions(string $collection, string $id, array $formatOptions): Document
     {
-        return $this->delegate(__FUNCTION__, [$collection, $id, $formatOptions]);
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, [$collection, $id, $formatOptions]);
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateAttributeFilters(string $collection, string $id, array $filters): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateAttributeDefault(string $collection, string $id, mixed $default = null): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function renameAttribute(string $collection, string $old, string $new): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function createRelationship(
-        string $collection,
-        string $relatedCollection,
-        string $type,
-        bool $twoWay = false,
-        ?string $id = null,
-        ?string $twoWayKey = null,
-        string $onDelete = Database::RELATION_MUTATE_RESTRICT
-    ): bool {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+    /**
+     * {@inheritdoc}
+     */
+    public function createRelationship(Relationship $relationship): bool
+    {
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, [$relationship]);
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateRelationship(
         string $collection,
         string $id,
         ?string $newKey = null,
         ?string $newTwoWayKey = null,
         ?bool $twoWay = null,
-        ?string $onDelete = null
+        ?ForeignKeyAction $onDelete = null
     ): bool {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function deleteRelationship(string $collection, string $id): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-
+    /**
+     * {@inheritdoc}
+     */
     public function renameIndex(string $collection, string $old, string $new): bool
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value = 1, int|float|null $max = null): Document
+    /**
+     * {@inheritdoc}
+     */
+    public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float|string $value = 1, int|float|string|null $max = null): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function decreaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value = 1, int|float|null $min = null): Document
+    /**
+     * {@inheritdoc}
+     */
+    public function decreaseDocumentAttribute(string $collection, string $id, string $attribute, int|float|string $value = 1, int|float|string|null $min = null): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     /**
+     * Create the upgrades tracking collection in the source database if it does not exist.
+     *
+     * @return void
      * @throws Limit
      * @throws DuplicateException
      * @throws Exception
@@ -1052,53 +1297,17 @@ public function createUpgrades(): void
     {
         $collection = $this->source->getCollection('upgrades');
 
-        if (!$collection->isEmpty()) {
+        if (! $collection->isEmpty()) {
             return;
         }
 
-        $this->source->createCollection(
-            id: 'upgrades',
-            attributes: [
-                new Document([
-                    '$id' => ID::custom('collectionId'),
-                    'type' => Database::VAR_STRING,
-                    'size' => Database::LENGTH_KEY,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                    'default' => null,
-                    'format' => ''
-                ]),
-                new Document([
-                    '$id' => ID::custom('status'),
-                    'type' => Database::VAR_STRING,
-                    'size' => Database::LENGTH_KEY,
-                    'required' => false,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                    'default' => null,
-                    'format' => ''
-                ]),
-            ],
-            indexes: [
-                new Document([
-                    '$id' => ID::custom('_unique_collection'),
-                    'type' => Database::INDEX_UNIQUE,
-                    'attributes' => ['collectionId'],
-                    'lengths' => [Database::LENGTH_KEY],
-                    'orders' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('_status_index'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => ['status'],
-                    'lengths' => [Database::LENGTH_KEY],
-                    'orders' => [Database::ORDER_ASC],
-                ]),
-            ],
-        );
+        $this->source->createCollection(new Collection(id: 'upgrades', attributes: [
+            Attribute::string(key: 'collectionId', required: true),
+            Attribute::string(key: 'status'),
+        ], indexes: [
+            Index::unique(key: '_unique_collection', attributes: ['collectionId'], lengths: [Database::LENGTH_KEY]),
+            Index::key(key: '_status_index', attributes: ['status'], lengths: [Database::LENGTH_KEY], orders: [Order::Asc]),
+        ]));
     }
 
     /**
@@ -1113,53 +1322,73 @@ protected function getUpgradeStatus(string $collection): ?Document
         return $this->getSource()->getAuthorization()->skip(function () use ($collection) {
             try {
                 return $this->source->getDocument('upgrades', $collection);
-            } catch (\Throwable) {
+            } catch (Throwable) {
                 return;
             }
         });
     }
 
-    protected function logError(string $action, \Throwable $err): void
+    protected function logError(string $action, Throwable $err): void
     {
         foreach ($this->errorCallbacks as $callback) {
             $callback($action, $err);
         }
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setAuthorization(Authorization $authorization): self
     {
 
         parent::setAuthorization($authorization);
 
-        if (isset($this->source)) {
-            $this->source->setAuthorization($authorization);
-        }
-        if (isset($this->destination)) {
+        $this->source->setAuthorization($authorization);
+
+        if ($this->destination !== null) {
             $this->destination->setAuthorization($authorization);
         }
 
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function addHook(\Utopia\Query\Hook $hook): static
+    {
+        parent::addHook($hook);
+
+        if ($hook instanceof Relationships) {
+            $this->source->addHook(new Relationships($this->source));
+            $this->destination?->addHook(new Relationships($this->destination));
+        }
+
+        if ($hook instanceof Write) {
+            $this->destination?->getAdapter()->addWriteHook($hook);
+        }
+
+        return $this;
+    }
+
     /**
      * Set custom document class for a collection
      *
-     * @param string $collection Collection ID
-     * @param class-string<Document> $className Fully qualified class name that extends Document
-     * @return static
+     * @param  string  $collection  Collection ID
+     * @param  class-string<Document>  $className  Fully qualified class name that extends Document
      */
     public function setDocumentType(string $collection, string $className): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
         $this->documentTypes[$collection] = $className;
+
         return $this;
     }
 
     /**
      * Clear document type mapping for a collection
      *
-     * @param string $collection Collection ID
-     * @return static
+     * @param  string  $collection  Collection ID
      */
     public function clearDocumentType(string $collection): static
     {
@@ -1171,8 +1400,6 @@ public function clearDocumentType(string $collection): static
 
     /**
      * Clear all document type mappings
-     *
-     * @return static
      */
     public function clearAllDocumentTypes(): static
     {
@@ -1181,5 +1408,4 @@ public function clearAllDocumentTypes(): static
 
         return $this;
     }
-
 }
diff --git a/src/Database/Mirroring/Filter.php b/src/Database/Mirroring/Filter.php
index 2da00534b1..b1e61b2714 100644
--- a/src/Database/Mirroring/Filter.php
+++ b/src/Database/Mirroring/Filter.php
@@ -6,13 +6,16 @@
 use Utopia\Database\Document;
 use Utopia\Database\Query;
 
+/**
+ * Abstract filter for intercepting and transforming mirrored database operations between source and destination.
+ */
 abstract class Filter
 {
     /**
      * Called before any action is executed, when the filter is constructed.
      *
-     * @param Database $source
-     * @param ?Database $destination
+     * @param Database $source The source database instance
+     * @param Database|null $destination The destination database instance, or null if unavailable
      * @return void
      */
     public function init(
@@ -24,8 +27,8 @@ public function init(
     /**
      * Called after all actions are executed, when the filter is destructed.
      *
-     * @param Database $source
-     * @param ?Database $destination
+     * @param Database $source The source database instance
+     * @param Database|null $destination The destination database instance, or null if unavailable
      * @return void
      */
     public function shutdown(
@@ -35,13 +38,13 @@ public function shutdown(
     }
 
     /**
-     * Called before collection is created in the destination database
+     * Called before a collection is created in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param ?Document $collection
-     * @return ?Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document|null $collection The collection document, or null to skip creation
+     * @return Document|null The possibly transformed collection document, or null to skip
      */
     public function beforeCreateCollection(
         Database $source,
@@ -53,13 +56,13 @@ public function beforeCreateCollection(
     }
 
     /**
-     * Called before collection is updated in the destination database
+     * Called before a collection is updated in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param ?Document $collection
-     * @return ?Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document|null $collection The collection document, or null to skip update
+     * @return Document|null The possibly transformed collection document, or null to skip
      */
     public function beforeUpdateCollection(
         Database $source,
@@ -71,11 +74,11 @@ public function beforeUpdateCollection(
     }
 
     /**
-     * Called after collection is deleted in the destination database
+     * Called before a collection is deleted in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
      * @return void
      */
     public function beforeDeleteCollection(
@@ -86,12 +89,14 @@ public function beforeDeleteCollection(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $attributeId
-     * @param ?Document $attribute
-     * @return ?Document
+     * Called before an attribute is created in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $attributeId The attribute identifier
+     * @param Document|null $attribute The attribute document, or null to skip creation
+     * @return Document|null The possibly transformed attribute document, or null to skip
      */
     public function beforeCreateAttribute(
         Database $source,
@@ -104,12 +109,14 @@ public function beforeCreateAttribute(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $attributeId
-     * @param ?Document $attribute
-     * @return ?Document
+     * Called before an attribute is updated in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $attributeId The attribute identifier
+     * @param Document|null $attribute The attribute document, or null to skip update
+     * @return Document|null The possibly transformed attribute document, or null to skip
      */
     public function beforeUpdateAttribute(
         Database $source,
@@ -122,10 +129,12 @@ public function beforeUpdateAttribute(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $attributeId
+     * Called before an attribute is deleted in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $attributeId The attribute identifier
      * @return void
      */
     public function beforeDeleteAttribute(
@@ -136,15 +145,15 @@ public function beforeDeleteAttribute(
     ): void {
     }
 
-    // Indexes
-
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $indexId
-     * @param ?Document $index
-     * @return ?Document
+     * Called before an index is created in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $indexId The index identifier
+     * @param Document|null $index The index document, or null to skip creation
+     * @return Document|null The possibly transformed index document, or null to skip
      */
     public function beforeCreateIndex(
         Database $source,
@@ -157,12 +166,14 @@ public function beforeCreateIndex(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $indexId
-     * @param ?Document $index
-     * @return ?Document
+     * Called before an index is updated in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $indexId The index identifier
+     * @param Document|null $index The index document, or null to skip update
+     * @return Document|null The possibly transformed index document, or null to skip
      */
     public function beforeUpdateIndex(
         Database $source,
@@ -175,10 +186,12 @@ public function beforeUpdateIndex(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $indexId
+     * Called before an index is deleted in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $indexId The index identifier
      * @return void
      */
     public function beforeDeleteIndex(
@@ -190,13 +203,13 @@ public function beforeDeleteIndex(
     }
 
     /**
-     * Called before document is created in the destination database
+     * Called before a document is created in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The document to create
+     * @return Document The possibly transformed document
      */
     public function beforeCreateDocument(
         Database $source,
@@ -208,13 +221,13 @@ public function beforeCreateDocument(
     }
 
     /**
-     * Called after document is created in the destination database
+     * Called after a document is created in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The created document
+     * @return Document The possibly transformed document
      */
     public function afterCreateDocument(
         Database $source,
@@ -226,13 +239,13 @@ public function afterCreateDocument(
     }
 
     /**
-     * Called before document is updated in the destination database
+     * Called before a document is updated in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The document to update
+     * @return Document The possibly transformed document
      */
     public function beforeUpdateDocument(
         Database $source,
@@ -244,13 +257,13 @@ public function beforeUpdateDocument(
     }
 
     /**
-     * Called after document is updated in the destination database
+     * Called after a document is updated in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The updated document
+     * @return Document The possibly transformed document
      */
     public function afterUpdateDocument(
         Database $source,
@@ -262,12 +275,14 @@ public function afterUpdateDocument(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $updates
-     * @param array<Query> $queries
-     * @return Document
+     * Called before documents are bulk-updated in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $updates The document containing the update fields
+     * @param array<Query> $queries The queries filtering which documents to update
+     * @return Document The possibly transformed updates document
      */
     public function beforeUpdateDocuments(
         Database $source,
@@ -280,11 +295,13 @@ public function beforeUpdateDocuments(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $updates
-     * @param array<Query> $queries
+     * Called after documents are bulk-updated in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $updates The document containing the update fields
+     * @param array<Query> $queries The queries filtering which documents were updated
      * @return void
      */
     public function afterUpdateDocuments(
@@ -297,12 +314,12 @@ public function afterUpdateDocuments(
     }
 
     /**
-     * Called before document is deleted in the destination database
+     * Called before a document is deleted in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $documentId
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $documentId The document identifier
      * @return void
      */
     public function beforeDeleteDocument(
@@ -314,12 +331,12 @@ public function beforeDeleteDocument(
     }
 
     /**
-     * Called after document is deleted in the destination database
+     * Called after a document is deleted in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param string $documentId
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param string $documentId The document identifier
      * @return void
      */
     public function afterDeleteDocument(
@@ -331,10 +348,12 @@ public function afterDeleteDocument(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param array<Query> $queries
+     * Called before documents are bulk-deleted in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param array<Query> $queries The queries filtering which documents to delete
      * @return void
      */
     public function beforeDeleteDocuments(
@@ -346,10 +365,12 @@ public function beforeDeleteDocuments(
     }
 
     /**
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param array<Query> $queries
+     * Called after documents are bulk-deleted in the destination database.
+     *
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param array<Query> $queries The queries filtering which documents were deleted
      * @return void
      */
     public function afterDeleteDocuments(
@@ -361,13 +382,13 @@ public function afterDeleteDocuments(
     }
 
     /**
-     * Called before document is upserted in the destination database
+     * Called before a document is upserted in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The document to upsert
+     * @return Document The possibly transformed document
      */
     public function beforeCreateOrUpdateDocument(
         Database $source,
@@ -379,13 +400,13 @@ public function beforeCreateOrUpdateDocument(
     }
 
     /**
-     * Called after document is upserted in the destination database
+     * Called after a document is upserted in the destination database.
      *
-     * @param Database $source
-     * @param Database $destination
-     * @param string $collectionId
-     * @param Document $document
-     * @return Document
+     * @param Database $source The source database instance
+     * @param Database $destination The destination database instance
+     * @param string $collectionId The collection identifier
+     * @param Document $document The upserted document
+     * @return Document The possibly transformed document
      */
     public function afterCreateOrUpdateDocument(
         Database $source,
diff --git a/src/Database/Operator.php b/src/Database/Operator.php
index c43d767097..d701a4ef6b 100644
--- a/src/Database/Operator.php
+++ b/src/Database/Operator.php
@@ -13,132 +13,37 @@
  */
 class Operator
 {
-    // Numeric operation types
-    public const TYPE_INCREMENT = 'increment';
-    public const TYPE_DECREMENT = 'decrement';
-    public const TYPE_MODULO = 'modulo';
-    public const TYPE_POWER = 'power';
-    public const TYPE_MULTIPLY = 'multiply';
-    public const TYPE_DIVIDE = 'divide';
-
-    // Array operation types
-    public const TYPE_ARRAY_APPEND = 'arrayAppend';
-    public const TYPE_ARRAY_PREPEND = 'arrayPrepend';
-    public const TYPE_ARRAY_INSERT = 'arrayInsert';
-    public const TYPE_ARRAY_REMOVE = 'arrayRemove';
-    public const TYPE_ARRAY_UNIQUE = 'arrayUnique';
-    public const TYPE_ARRAY_INTERSECT = 'arrayIntersect';
-    public const TYPE_ARRAY_DIFF = 'arrayDiff';
-    public const TYPE_ARRAY_FILTER = 'arrayFilter';
-
-    // String operation types
-    public const TYPE_STRING_CONCAT = 'stringConcat';
-    public const TYPE_STRING_REPLACE = 'stringReplace';
-
-    // Boolean operation types
-    public const TYPE_TOGGLE = 'toggle';
-
-    // Date operation types
-    public const TYPE_DATE_ADD_DAYS = 'dateAddDays';
-    public const TYPE_DATE_SUB_DAYS = 'dateSubDays';
-    public const TYPE_DATE_SET_NOW = 'dateSetNow';
-
-    public const TYPES = [
-        self::TYPE_INCREMENT,
-        self::TYPE_DECREMENT,
-        self::TYPE_MULTIPLY,
-        self::TYPE_DIVIDE,
-        self::TYPE_MODULO,
-        self::TYPE_POWER,
-        self::TYPE_STRING_CONCAT,
-        self::TYPE_STRING_REPLACE,
-        self::TYPE_ARRAY_APPEND,
-        self::TYPE_ARRAY_PREPEND,
-        self::TYPE_ARRAY_INSERT,
-        self::TYPE_ARRAY_REMOVE,
-        self::TYPE_ARRAY_UNIQUE,
-        self::TYPE_ARRAY_INTERSECT,
-        self::TYPE_ARRAY_DIFF,
-        self::TYPE_ARRAY_FILTER,
-        self::TYPE_TOGGLE,
-        self::TYPE_DATE_ADD_DAYS,
-        self::TYPE_DATE_SUB_DAYS,
-        self::TYPE_DATE_SET_NOW,
-    ];
-
     /**
      * Maximum number of values a single array operator (append/prepend/intersect/diff) may carry,
      * to guard against memory exhaustion. Enforced consistently across all adapters.
      */
-    public const MAX_ARRAY_OPERATOR_SIZE = 10000;
+    public const int MAX_ARRAY_OPERATOR_SIZE = 10_000;
 
     /**
      * Conditions accepted by the arrayFilter operator.
      */
-    public const ARRAY_FILTER_CONDITIONS = [
+    public const array ARRAY_FILTER_CONDITIONS = [
         'equal', 'notEqual',                                            // comparison
         'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual', // numeric
         'isNull', 'isNotNull',                                          // null checks
     ];
-
-    protected const NUMERIC_TYPES = [
-        self::TYPE_INCREMENT,
-        self::TYPE_DECREMENT,
-        self::TYPE_MULTIPLY,
-        self::TYPE_DIVIDE,
-        self::TYPE_MODULO,
-        self::TYPE_POWER,
-    ];
-
-    protected const ARRAY_TYPES = [
-        self::TYPE_ARRAY_APPEND,
-        self::TYPE_ARRAY_PREPEND,
-        self::TYPE_ARRAY_INSERT,
-        self::TYPE_ARRAY_REMOVE,
-        self::TYPE_ARRAY_UNIQUE,
-        self::TYPE_ARRAY_INTERSECT,
-        self::TYPE_ARRAY_DIFF,
-        self::TYPE_ARRAY_FILTER,
-    ];
-
-    protected const STRING_TYPES = [
-        self::TYPE_STRING_CONCAT,
-        self::TYPE_STRING_REPLACE,
-    ];
-
-    protected const BOOLEAN_TYPES = [
-        self::TYPE_TOGGLE,
-    ];
-
-
-    protected const DATE_TYPES = [
-        self::TYPE_DATE_ADD_DAYS,
-        self::TYPE_DATE_SUB_DAYS,
-        self::TYPE_DATE_SET_NOW,
-    ];
-
-    protected string $method = '';
-    protected string $attribute = '';
-
-    /**
-     * @var array<mixed>
-     */
-    protected array $values = [];
-
     /**
      * Construct a new operator object
      *
-     * @param string $method
-     * @param string $attribute
-     * @param array<mixed> $values
+     * @param  array<mixed>  $values
      */
-    public function __construct(string $method, string $attribute = '', array $values = [])
-    {
-        $this->method = $method;
-        $this->attribute = $attribute;
-        $this->values = $values;
+    public function __construct(
+        protected OperatorType $method,
+        protected string $attribute = '',
+        protected array $values = [],
+    ) {
     }
 
+    /**
+     * Deep clone operator values that are themselves Operator instances.
+     *
+     * @return void
+     */
     public function __clone(): void
     {
         foreach ($this->values as $index => $value) {
@@ -149,14 +54,18 @@ public function __clone(): void
     }
 
     /**
-     * @return string
+     * Get the operator method type.
+     *
+     * @return OperatorType
      */
-    public function getMethod(): string
+    public function getMethod(): OperatorType
     {
         return $this->method;
     }
 
     /**
+     * Get the target attribute name.
+     *
      * @return string
      */
     public function getAttribute(): string
@@ -165,6 +74,8 @@ public function getAttribute(): string
     }
 
     /**
+     * Get all operator values.
+     *
      * @return array<mixed>
      */
     public function getValues(): array
@@ -173,7 +84,9 @@ public function getValues(): array
     }
 
     /**
-     * @param mixed $default
+     * Get the first value, or a default if none is set.
+     *
+     * @param mixed $default The fallback value
      * @return mixed
      */
     public function getValue(mixed $default = null): mixed
@@ -184,10 +97,10 @@ public function getValue(mixed $default = null): mixed
     /**
      * Sets method
      *
-     * @param string $method
+     * @param OperatorType $method The operator method type
      * @return self
      */
-    public function setMethod(string $method): self
+    public function setMethod(OperatorType $method): self
     {
         $this->method = $method;
 
@@ -197,7 +110,7 @@ public function setMethod(string $method): self
     /**
      * Sets attribute
      *
-     * @param string $attribute
+     * @param string $attribute The target attribute name
      * @return self
      */
     public function setAttribute(string $attribute): self
@@ -210,7 +123,7 @@ public function setAttribute(string $attribute): self
     /**
      * Sets values
      *
-     * @param array<mixed> $values
+     * @param  array<mixed>  $values
      * @return self
      */
     public function setValues(array $values): self
@@ -222,7 +135,8 @@ public function setValues(array $values): self
 
     /**
      * Sets value
-     * @param mixed $value
+     *
+     * @param mixed $value The value to set
      * @return self
      */
     public function setValue(mixed $value): self
@@ -235,34 +149,16 @@ public function setValue(mixed $value): self
     /**
      * Check if method is supported
      *
-     * @param string $value
+     * @param OperatorType|string $value The method to check
      * @return bool
      */
-    public static function isMethod(string $value): bool
-    {
-        return match ($value) {
-            self::TYPE_INCREMENT,
-            self::TYPE_DECREMENT,
-            self::TYPE_MULTIPLY,
-            self::TYPE_DIVIDE,
-            self::TYPE_MODULO,
-            self::TYPE_POWER,
-            self::TYPE_STRING_CONCAT,
-            self::TYPE_STRING_REPLACE,
-            self::TYPE_ARRAY_APPEND,
-            self::TYPE_ARRAY_PREPEND,
-            self::TYPE_ARRAY_INSERT,
-            self::TYPE_ARRAY_REMOVE,
-            self::TYPE_ARRAY_UNIQUE,
-            self::TYPE_ARRAY_INTERSECT,
-            self::TYPE_ARRAY_DIFF,
-            self::TYPE_ARRAY_FILTER,
-            self::TYPE_TOGGLE,
-            self::TYPE_DATE_ADD_DAYS,
-            self::TYPE_DATE_SUB_DAYS,
-            self::TYPE_DATE_SET_NOW => true,
-            default => false,
-        };
+    public static function isMethod(OperatorType|string $value): bool
+    {
+        if ($value instanceof OperatorType) {
+            return true;
+        }
+
+        return OperatorType::tryFrom($value) !== null;
     }
 
     /**
@@ -272,7 +168,7 @@ public static function isMethod(string $value): bool
      */
     public function isNumericOperation(): bool
     {
-        return \in_array($this->method, self::NUMERIC_TYPES);
+        return $this->method->isNumeric();
     }
 
     /**
@@ -282,7 +178,7 @@ public function isNumericOperation(): bool
      */
     public function isArrayOperation(): bool
     {
-        return \in_array($this->method, self::ARRAY_TYPES);
+        return $this->method->isArray();
     }
 
     /**
@@ -292,7 +188,7 @@ public function isArrayOperation(): bool
      */
     public function isStringOperation(): bool
     {
-        return \in_array($this->method, self::STRING_TYPES);
+        return $this->method->isString();
     }
 
     /**
@@ -302,10 +198,9 @@ public function isStringOperation(): bool
      */
     public function isBooleanOperation(): bool
     {
-        return \in_array($this->method, self::BOOLEAN_TYPES);
+        return $this->method->isBoolean();
     }
 
-
     /**
      * Check if method is a date operation
      *
@@ -313,13 +208,13 @@ public function isBooleanOperation(): bool
      */
     public function isDateOperation(): bool
     {
-        return \in_array($this->method, self::DATE_TYPES);
+        return $this->method->isDate();
     }
 
     /**
      * Parse operator from string
      *
-     * @param string $operator
+     * @param string $operator JSON-encoded operator string
      * @return self
      * @throws OperatorException
      */
@@ -327,21 +222,22 @@ public static function parse(string $operator): self
     {
         try {
             $operator = \json_decode($operator, true, flags: JSON_THROW_ON_ERROR);
-        } catch (\JsonException $e) {
-            throw new OperatorException('Invalid operator: ' . $e->getMessage());
+        } catch (JsonException $e) {
+            throw new OperatorException('Invalid operator: '.$e->getMessage());
         }
 
-        if (!\is_array($operator)) {
-            throw new OperatorException('Invalid operator. Must be an array, got ' . \gettype($operator));
+        if (! \is_array($operator)) {
+            throw new OperatorException('Invalid operator. Must be an array, got '.\gettype($operator));
         }
 
+        /** @var array<string, mixed> $operator */
         return self::parseOperator($operator);
     }
 
     /**
      * Parse operator from array
      *
-     * @param array<string, mixed> $operator
+     * @param  array<string, mixed>  $operator
      * @return self
      * @throws OperatorException
      */
@@ -351,57 +247,56 @@ public static function parseOperator(array $operator): self
         $attribute = $operator['attribute'] ?? '';
         $values = $operator['values'] ?? [];
 
-        if (!\is_string($method)) {
-            throw new OperatorException('Invalid operator method. Must be a string, got ' . \gettype($method));
+        if (! \is_string($method)) {
+            throw new OperatorException('Invalid operator method. Must be a string, got '.\gettype($method));
         }
 
-        if (!self::isMethod($method)) {
-            throw new OperatorException('Invalid operator method: ' . $method);
+        $operatorType = OperatorType::tryFrom($method);
+        if ($operatorType === null) {
+            throw new OperatorException('Invalid operator method: '.$method);
         }
 
-        if (!\is_string($attribute)) {
-            throw new OperatorException('Invalid operator attribute. Must be a string, got ' . \gettype($attribute));
+        if (! \is_string($attribute)) {
+            throw new OperatorException('Invalid operator attribute. Must be a string, got '.\gettype($attribute));
         }
 
-        if (!\is_array($values)) {
-            throw new OperatorException('Invalid operator values. Must be an array, got ' . \gettype($values));
+        if (! \is_array($values)) {
+            throw new OperatorException('Invalid operator values. Must be an array, got '.\gettype($values));
         }
 
-        return new self($method, $attribute, $values);
+        return new self($operatorType, $attribute, $values);
     }
 
     /**
      * Parse an array of operators
      *
-     * @param array<string> $operators
-     *
+     * @param  array<string>  $operators
      * @return array<Operator>
+     *
      * @throws OperatorException
      */
     public static function parseOperators(array $operators): array
     {
-        $parsed = [];
-
-        foreach ($operators as $operator) {
-            $parsed[] = self::parse($operator);
-        }
-
-        return $parsed;
+        return \array_map(self::parse(...), $operators);
     }
 
     /**
+     * Convert this operator to an associative array.
+     *
      * @return array<string, mixed>
      */
     public function toArray(): array
     {
         return [
-            'method' => $this->method,
+            'method' => $this->method->value,
             'attribute' => $this->attribute,
             'values' => $this->values,
         ];
     }
 
     /**
+     * Serialize this operator to a JSON string.
+     *
      * @return string
      * @throws OperatorException
      */
@@ -410,136 +305,138 @@ public function toString(): string
         try {
             return \json_encode($this->toArray(), flags: JSON_THROW_ON_ERROR);
         } catch (JsonException $e) {
-            throw new OperatorException('Invalid Json: ' . $e->getMessage());
+            throw new OperatorException('Invalid Json: '.$e->getMessage());
         }
     }
 
     /**
      * Helper method to create increment operator
      *
-     * @param int|float $value
-     * @param int|float|null $max Maximum value (won't increment beyond this)
-     * @return Operator
+     * @param int|float|string $value The amount to increment by
+     * @param  int|float|string|null  $max  Maximum value (won't increment beyond this)
+     * @return self
      */
-    public static function increment(int|float $value = 1, int|float|null $max = null): self
+    public static function increment(int|float|string $value = 1, int|float|string|null $max = null): self
     {
         $values = [$value];
         if ($max !== null) {
             $values[] = $max;
         }
-        return new self(self::TYPE_INCREMENT, '', $values);
+
+        return new self(OperatorType::Increment, '', $values);
     }
 
     /**
      * Helper method to create decrement operator
      *
-     * @param int|float $value
-     * @param int|float|null $min Minimum value (won't decrement below this)
-     * @return Operator
+     * @param int|float|string $value The amount to decrement by
+     * @param  int|float|string|null  $min  Minimum value (won't decrement below this)
+     * @return self
      */
-    public static function decrement(int|float $value = 1, int|float|null $min = null): self
+    public static function decrement(int|float|string $value = 1, int|float|string|null $min = null): self
     {
         $values = [$value];
         if ($min !== null) {
             $values[] = $min;
         }
-        return new self(self::TYPE_DECREMENT, '', $values);
-    }
 
+        return new self(OperatorType::Decrement, '', $values);
+    }
 
     /**
      * Helper method to create array append operator
      *
-     * @param array<mixed> $values
-     * @return Operator
+     * @param  array<mixed>  $values
+     * @return self
      */
     public static function arrayAppend(array $values): self
     {
-        return new self(self::TYPE_ARRAY_APPEND, '', $values);
+        return new self(OperatorType::ArrayAppend, '', $values);
     }
 
     /**
      * Helper method to create array prepend operator
      *
-     * @param array<mixed> $values
-     * @return Operator
+     * @param  array<mixed>  $values
+     * @return self
      */
     public static function arrayPrepend(array $values): self
     {
-        return new self(self::TYPE_ARRAY_PREPEND, '', $values);
+        return new self(OperatorType::ArrayPrepend, '', $values);
     }
 
     /**
      * Helper method to create array insert operator
      *
-     * @param int $index
-     * @param mixed $value
-     * @return Operator
+     * @param int $index The position to insert at
+     * @param mixed $value The value to insert
+     * @return self
      */
     public static function arrayInsert(int $index, mixed $value): self
     {
-        return new self(self::TYPE_ARRAY_INSERT, '', [$index, $value]);
+        return new self(OperatorType::ArrayInsert, '', [$index, $value]);
     }
 
     /**
      * Helper method to create array remove operator
      *
-     * @param mixed $value
-     * @return Operator
+     * @param mixed $value The value to remove
+     * @return self
      */
     public static function arrayRemove(mixed $value): self
     {
-        return new self(self::TYPE_ARRAY_REMOVE, '', [$value]);
+        return new self(OperatorType::ArrayRemove, '', [$value]);
     }
 
     /**
      * Helper method to create concatenation operator
      *
-     * @param mixed $value Value to concatenate (string or array)
-     * @return Operator
+     * @param  mixed  $value  Value to concatenate (string or array)
+     * @return self
      */
     public static function stringConcat(mixed $value): self
     {
-        return new self(self::TYPE_STRING_CONCAT, '', [$value]);
+        return new self(OperatorType::StringConcat, '', [$value]);
     }
 
     /**
      * Helper method to create replace operator
      *
-     * @param string $search
-     * @param string $replace
-     * @return Operator
+     * @param string $search The substring to search for
+     * @param string $replace The replacement string
+     * @return self
      */
     public static function stringReplace(string $search, string $replace): self
     {
-        return new self(self::TYPE_STRING_REPLACE, '', [$search, $replace]);
+        return new self(OperatorType::StringReplace, '', [$search, $replace]);
     }
 
     /**
      * Helper method to create multiply operator
      *
-     * @param int|float $factor
-     * @param int|float|null $max Maximum value (won't multiply beyond this)
-     * @return Operator
+     * @param int|float|string $factor The factor to multiply by
+     * @param  int|float|string|null  $max  Maximum value (won't multiply beyond this)
+     * @return self
      */
-    public static function multiply(int|float $factor, int|float|null $max = null): self
+    public static function multiply(int|float|string $factor, int|float|string|null $max = null): self
     {
         $values = [$factor];
         if ($max !== null) {
             $values[] = $max;
         }
-        return new self(self::TYPE_MULTIPLY, '', $values);
+
+        return new self(OperatorType::Multiply, '', $values);
     }
 
     /**
      * Helper method to create divide operator
      *
-     * @param int|float $divisor
-     * @param int|float|null $min Minimum value (won't divide below this)
-     * @return Operator
+     * @param int|float|string $divisor The divisor
+     * @param  int|float|string|null  $min  Minimum value (won't divide below this)
+     * @return self
      * @throws OperatorException if divisor is zero
      */
-    public static function divide(int|float $divisor, int|float|null $min = null): self
+    public static function divide(int|float|string $divisor, int|float|string|null $min = null): self
     {
         if ($divisor == 0) {
             throw new OperatorException('Division by zero is not allowed');
@@ -548,132 +445,133 @@ public static function divide(int|float $divisor, int|float|null $min = null): s
         if ($min !== null) {
             $values[] = $min;
         }
-        return new self(self::TYPE_DIVIDE, '', $values);
+
+        return new self(OperatorType::Divide, '', $values);
     }
 
     /**
      * Helper method to create toggle operator
      *
-     * @return Operator
+     * @return self
      */
     public static function toggle(): self
     {
-        return new self(self::TYPE_TOGGLE, '', []);
+        return new self(OperatorType::Toggle, '', []);
     }
 
-
     /**
      * Helper method to create date add days operator
      *
-     * @param int $days Number of days to add (can be negative to subtract)
-     * @return Operator
+     * @param  int  $days  Number of days to add (can be negative to subtract)
+     * @return self
      */
     public static function dateAddDays(int $days): self
     {
-        return new self(self::TYPE_DATE_ADD_DAYS, '', [$days]);
+        return new self(OperatorType::DateAddDays, '', [$days]);
     }
 
     /**
      * Helper method to create date subtract days operator
      *
-     * @param int $days Number of days to subtract
-     * @return Operator
+     * @param  int  $days  Number of days to subtract
+     * @return self
      */
     public static function dateSubDays(int $days): self
     {
-        return new self(self::TYPE_DATE_SUB_DAYS, '', [$days]);
+        return new self(OperatorType::DateSubDays, '', [$days]);
     }
 
     /**
      * Helper method to create date set now operator
      *
-     * @return Operator
+     * @return self
      */
     public static function dateSetNow(): self
     {
-        return new self(self::TYPE_DATE_SET_NOW, '', []);
+        return new self(OperatorType::DateSetNow, '', []);
     }
 
     /**
      * Helper method to create modulo operator
      *
-     * @param int|float $divisor The divisor for modulo operation
-     * @return Operator
+     * @param  int|float|string  $divisor  The divisor for modulo operation
+     * @return self
      * @throws OperatorException if divisor is zero
      */
-    public static function modulo(int|float $divisor): self
+    public static function modulo(int|float|string $divisor): self
     {
         if ($divisor == 0) {
             throw new OperatorException('Modulo by zero is not allowed');
         }
-        return new self(self::TYPE_MODULO, '', [$divisor]);
+
+        return new self(OperatorType::Modulo, '', [$divisor]);
     }
 
     /**
      * Helper method to create power operator
      *
-     * @param int|float $exponent The exponent to raise to
-     * @param int|float|null $max Maximum value (won't exceed this)
-     * @return Operator
+     * @param  int|float|string  $exponent  The exponent to raise to
+     * @param  int|float|string|null  $max  Maximum value (won't exceed this)
+     * @return self
      */
-    public static function power(int|float $exponent, int|float|null $max = null): self
+    public static function power(int|float|string $exponent, int|float|string|null $max = null): self
     {
         $values = [$exponent];
         if ($max !== null) {
             $values[] = $max;
         }
-        return new self(self::TYPE_POWER, '', $values);
-    }
 
+        return new self(OperatorType::Power, '', $values);
+    }
 
     /**
      * Helper method to create array unique operator
      *
-     * @return Operator
+     * @return self
      */
     public static function arrayUnique(): self
     {
-        return new self(self::TYPE_ARRAY_UNIQUE, '', []);
+        return new self(OperatorType::ArrayUnique, '', []);
     }
 
     /**
      * Helper method to create array intersect operator
      *
-     * @param array<mixed> $values Values to intersect with current array
-     * @return Operator
+     * @param  array<mixed>  $values  Values to intersect with current array
+     * @return self
      */
     public static function arrayIntersect(array $values): self
     {
-        return new self(self::TYPE_ARRAY_INTERSECT, '', $values);
+        return new self(OperatorType::ArrayIntersect, '', $values);
     }
 
     /**
      * Helper method to create array diff operator
      *
-     * @param array<mixed> $values Values to remove from current array
-     * @return Operator
+     * @param  array<mixed>  $values  Values to remove from current array
+     * @return self
      */
     public static function arrayDiff(array $values): self
     {
-        return new self(self::TYPE_ARRAY_DIFF, '', $values);
+        return new self(OperatorType::ArrayDiff, '', $values);
     }
 
     /**
      * Helper method to create array filter operator
      *
-     * @param string $condition Filter condition ('equals', 'notEquals', 'greaterThan', 'lessThan', 'null', 'notNull')
-     * @param mixed $value Value to filter by (not used for 'null'/'notNull' conditions)
-     * @return Operator
+     * @param  string  $condition  Filter condition ('equals', 'notEquals', 'greaterThan', 'lessThan', 'null', 'notNull')
+     * @param  mixed  $value  Value to filter by (not used for 'null'/'notNull' conditions)
+     * @return self
      */
     public static function arrayFilter(string $condition, mixed $value = null): self
     {
-        return new self(self::TYPE_ARRAY_FILTER, '', [$condition, $value]);
+        return new self(OperatorType::ArrayFilter, '', [$condition, $value]);
     }
 
     /**
      * Check if a value is an operator instance
      *
-     * @param mixed $value
+     * @param mixed $value The value to check
      * @return bool
      */
     public static function isOperator(mixed $value): bool
@@ -684,16 +582,17 @@ public static function isOperator(mixed $value): bool
     /**
      * Extract operators from document data
      *
-     * @param array<string, mixed> $data
+     * @param  array<string, mixed>  $data
      * @return array{operators: array<string, Operator>, updates: array<string, mixed>}
      */
     public static function extractOperators(array $data): array
     {
+        /** @var array<string, Operator> $operators */
         $operators = [];
         $updates = [];
 
         foreach ($data as $key => $value) {
-            if (self::isOperator($value)) {
+            if ($value instanceof self) {
                 // Set the attribute from the document key if not already set
                 if (empty($value->getAttribute())) {
                     $value->setAttribute($key);
@@ -709,5 +608,4 @@ public static function extractOperators(array $data): array
             'updates' => $updates,
         ];
     }
-
 }
diff --git a/src/Database/OperatorType.php b/src/Database/OperatorType.php
new file mode 100644
index 0000000000..ac75158ba3
--- /dev/null
+++ b/src/Database/OperatorType.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the types of atomic operations that can be performed on document attributes.
+ */
+enum OperatorType: string
+{
+    // Numeric operations
+    case Increment = 'increment';
+    case Decrement = 'decrement';
+    case Modulo = 'modulo';
+    case Power = 'power';
+    case Multiply = 'multiply';
+    case Divide = 'divide';
+
+    // Array operations
+    case ArrayAppend = 'arrayAppend';
+    case ArrayPrepend = 'arrayPrepend';
+    case ArrayInsert = 'arrayInsert';
+    case ArrayRemove = 'arrayRemove';
+    case ArrayUnique = 'arrayUnique';
+    case ArrayIntersect = 'arrayIntersect';
+    case ArrayDiff = 'arrayDiff';
+    case ArrayFilter = 'arrayFilter';
+
+    // String operations
+    case StringConcat = 'stringConcat';
+    case StringReplace = 'stringReplace';
+
+    // Boolean operations
+    case Toggle = 'toggle';
+
+    // Date operations
+    case DateAddDays = 'dateAddDays';
+    case DateSubDays = 'dateSubDays';
+    case DateSetNow = 'dateSetNow';
+
+    /**
+     * Check if this operator type is a numeric operation.
+     *
+     * @return bool
+     */
+    public function isNumeric(): bool
+    {
+        return match ($this) {
+            self::Increment,
+            self::Decrement,
+            self::Multiply,
+            self::Divide,
+            self::Modulo,
+            self::Power => true,
+            default => false,
+        };
+    }
+
+    /**
+     * Check if this operator type is an array operation.
+     *
+     * @return bool
+     */
+    public function isArray(): bool
+    {
+        return match ($this) {
+            self::ArrayAppend,
+            self::ArrayPrepend,
+            self::ArrayInsert,
+            self::ArrayRemove,
+            self::ArrayUnique,
+            self::ArrayIntersect,
+            self::ArrayDiff,
+            self::ArrayFilter => true,
+            default => false,
+        };
+    }
+
+    /**
+     * Check if this operator type is a string operation.
+     *
+     * @return bool
+     */
+    public function isString(): bool
+    {
+        return match ($this) {
+            self::StringConcat,
+            self::StringReplace => true,
+            default => false,
+        };
+    }
+
+    /**
+     * Check if this operator type is a boolean operation.
+     *
+     * @return bool
+     */
+    public function isBoolean(): bool
+    {
+        return match ($this) {
+            self::Toggle => true,
+            default => false,
+        };
+    }
+
+    /**
+     * Check if this operator type is a date operation.
+     *
+     * @return bool
+     */
+    public function isDate(): bool
+    {
+        return match ($this) {
+            self::DateAddDays,
+            self::DateSubDays,
+            self::DateSetNow => true,
+            default => false,
+        };
+    }
+}
diff --git a/src/Database/PDO.php b/src/Database/PDO.php
index 6981ca7cb3..01f013fd20 100644
--- a/src/Database/PDO.php
+++ b/src/Database/PDO.php
@@ -2,23 +2,40 @@
 
 namespace Utopia\Database;
 
+use Exception;
 use InvalidArgumentException;
+use PDO as PhpPDO;
+use PDOStatement as PhpPDOStatement;
+use Throwable;
 use Utopia\Console;
 
 /**
  * A PDO wrapper that forwards method calls to the internal PDO instance.
  *
- * @mixin \PDO
+ * @mixin PhpPDO
+ *
+ * @method int|false exec(string $statement)
+ * @method bool beginTransaction()
+ * @method bool commit()
+ * @method bool rollBack()
+ * @method bool inTransaction()
+ * @method string|false quote(string $string, int $type = PhpPDO::PARAM_STR)
+ * @method bool setAttribute(int $attribute, mixed $value)
+ * @method mixed getAttribute(int $attribute)
+ * @method string|false lastInsertId(?string $name = null)
+ * @method \PDOStatement|false query(string $query, ?int $fetchMode = null, mixed ...$fetchModeArgs)
  */
 class PDO
 {
-    protected \PDO $pdo;
+    protected PhpPDO $pdo;
 
     /**
-     * @param string $dsn
-     * @param ?string $username
-     * @param ?string $password
-     * @param array<mixed> $config
+     * Create a new PDO wrapper instance.
+     *
+     * @param string $dsn The Data Source Name
+     * @param string|null $username The database username
+     * @param string|null $password The database password
+     * @param  array<mixed>  $config PDO driver options
      */
     public function __construct(
         protected string $dsn,
@@ -26,9 +43,9 @@ public function __construct(
         protected ?string $password,
         protected array $config = []
     ) {
-        $this->config[\PDO::ATTR_ERRMODE] ??= \PDO::ERRMODE_EXCEPTION;
+        $this->config[PhpPDO::ATTR_ERRMODE] ??= PhpPDO::ERRMODE_EXCEPTION;
 
-        $this->pdo = new \PDO(
+        $this->pdo = new PhpPDO(
             $this->dsn,
             $this->username,
             $this->password,
@@ -37,12 +54,10 @@ public function __construct(
     }
 
     /**
-     * Prepare a statement, returning a wrapper that transparently re-prepares
-     * itself on the underlying connection if that connection is lost before the
-     * statement is executed.
+     * Prepare a statement that can re-prepare itself after connection recovery.
      *
-     * @param array<mixed> $options
-     * @throws \Throwable
+     * @param  array<mixed>  $options
+     * @throws Throwable
      */
     public function prepare(string $query, array $options = []): PDOStatement
     {
@@ -59,14 +74,14 @@ public function prepare(string $query, array $options = []): PDOStatement
      * with native prepares the server is contacted here, so a lost connection
      * outside a transaction is reconnected and retried, matching __call().
      *
-     * @param array<mixed> $options
-     * @throws \Throwable
+     * @param  array<mixed>  $options
+     * @throws Throwable
      */
-    public function prepareNative(string $query, array $options = []): \PDOStatement
+    public function prepareNative(string $query, array $options = []): PhpPDOStatement
     {
         try {
             $statement = $this->pdo->prepare($query, $options);
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             if (!Connection::hasError($e) || $this->pdo->inTransaction()) {
                 throw $e;
             }
@@ -83,18 +98,16 @@ public function prepareNative(string $query, array $options = []): \PDOStatement
     }
 
     /**
-     * @param string $method
-     * @param array<mixed> $args
-     * @return mixed
-     * @throws \Throwable
+     * @param  array<mixed>  $args
+     * @throws Throwable
      */
     public function __call(string $method, array $args): mixed
     {
         try {
             return $this->pdo->{$method}(...$args);
-        } catch (\Throwable $e) {
+        } catch (Throwable $e) {
             if (Connection::hasError($e)) {
-                Console::warning('[Database] ' . $e->getMessage());
+                Console::warning('[Database] '.$e->getMessage());
                 Console::warning('[Database] Lost connection detected. Reconnecting...');
 
                 $inTransaction = $this->pdo->inTransaction();
@@ -104,7 +117,7 @@ public function __call(string $method, array $args): mixed
 
                 // If we weren't in a transaction, also retry the query
                 // In a transaction we can't retry as the state is attached to the previous connection
-                if (!$inTransaction) {
+                if (! $inTransaction) {
                     return $this->pdo->{$method}(...$args);
                 }
             }
@@ -115,12 +128,10 @@ public function __call(string $method, array $args): mixed
 
     /**
      * Create a new connection to the database
-     *
-     * @return void
      */
     public function reconnect(): void
     {
-        $this->pdo = new \PDO(
+        $this->pdo = new PhpPDO(
             $this->dsn,
             $this->username,
             $this->password,
@@ -128,11 +139,15 @@ public function reconnect(): void
         );
     }
 
+    public function inTransaction(): bool
+    {
+        return $this->pdo->inTransaction();
+    }
+
     /**
      * Get the hostname from the DSN.
      *
-     * @return string
-     * @throws \Exception
+     * @throws Exception
      */
     public function getHostname(): string
     {
@@ -141,7 +156,7 @@ public function getHostname(): string
         /**
          * @var string $host
          */
-        $host = $parts['host'] ?? throw new \Exception('No host found in DSN');
+        $host = $parts['host'] ?? throw new Exception('No host found in DSN');
 
         return $host;
     }
@@ -150,11 +165,12 @@ public function getHostname(): string
      * Parse a PDO-style DSN string.
      *
      * @return array<string, string|int|float|bool|null>
+     *
      * @throws InvalidArgumentException If the DSN is malformed.
      */
     private function parseDsn(string $dsn): array
     {
-        if ($dsn === '' || !\str_contains($dsn, ':')) {
+        if ($dsn === '' || ! \str_contains($dsn, ':')) {
             throw new InvalidArgumentException('Malformed DSN: missing driver separator.');
         }
 
@@ -165,6 +181,7 @@ private function parseDsn(string $dsn): array
         // Handle “path only” DSNs like sqlite:/path/to.db
         if (\in_array($driver, ['sqlite'], true) && $parameterString !== '') {
             $parsed['path'] = \ltrim($parameterString, '/');
+
             return $parsed;
         }
 
@@ -173,7 +190,7 @@ private function parseDsn(string $dsn): array
         foreach ($parameterSegments as $segment) {
             [$name, $rawValue] = \array_pad(\explode('=', $segment, 2), 2, null);
 
-            $name  = \trim($name);
+            $name = \trim((string) $name);
             $value = $rawValue !== null ? \trim($rawValue) : null;
 
             // Casting for scalars
diff --git a/src/Database/PDOStatement.php b/src/Database/PDOStatement.php
index 5dbfc4d689..af734ca04e 100644
--- a/src/Database/PDOStatement.php
+++ b/src/Database/PDOStatement.php
@@ -49,10 +49,12 @@ class PDOStatement implements \IteratorAggregate
      */
     private array $attributes = [];
 
+    private ?int $fetchMode = null;
+
     /**
-     * @var array<int|string, mixed>|null
+     * @var array<int, mixed>
      */
-    private ?array $fetchMode = null;
+    private array $fetchModeArguments = [];
 
     /**
      * @param array<mixed> $options
@@ -139,7 +141,8 @@ public function setAttribute(int $attribute, mixed $value): bool
 
     public function setFetchMode(int $mode, mixed ...$args): bool
     {
-        $this->fetchMode = [$mode, ...$args];
+        $this->fetchMode = $mode;
+        $this->fetchModeArguments = \array_values($args);
 
         return $this->statement->setFetchMode($mode, ...$args);
     }
@@ -183,7 +186,7 @@ private function reprepare(): void
         }
 
         if ($this->fetchMode !== null) {
-            $this->statement->setFetchMode(...$this->fetchMode);
+            $this->statement->setFetchMode($this->fetchMode, ...$this->fetchModeArguments);
         }
 
         // Replay value/param bindings in the original call order so a placeholder
diff --git a/src/Database/PermissionType.php b/src/Database/PermissionType.php
new file mode 100644
index 0000000000..dac87c7230
--- /dev/null
+++ b/src/Database/PermissionType.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the types of permissions that can be granted on database resources.
+ */
+enum PermissionType: string
+{
+    case Create = 'create';
+    case Read = 'read';
+    case Update = 'update';
+    case Delete = 'delete';
+    case Write = 'write';
+}
diff --git a/src/Database/Profiler/QueryLog.php b/src/Database/Profiler/QueryLog.php
new file mode 100644
index 0000000000..6841cde787
--- /dev/null
+++ b/src/Database/Profiler/QueryLog.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Utopia\Database\Profiler;
+
+readonly class QueryLog
+{
+    /**
+     * @param  array<mixed>  $bindings
+     * @param  array<string>|null  $backtrace
+     */
+    public function __construct(
+        public string $query,
+        public array $bindings,
+        public float $durationMs,
+        public ?string $explainPlan = null,
+        public string $collection = '',
+        public string $operation = '',
+        public ?array $backtrace = null,
+    ) {
+    }
+}
diff --git a/src/Database/Profiler/QueryProfiler.php b/src/Database/Profiler/QueryProfiler.php
new file mode 100644
index 0000000000..6ce7716890
--- /dev/null
+++ b/src/Database/Profiler/QueryProfiler.php
@@ -0,0 +1,135 @@
+<?php
+
+namespace Utopia\Database\Profiler;
+
+class QueryProfiler
+{
+    /** @var array<QueryLog> */
+    private array $logs = [];
+
+    private float $slowThreshold = 100.0;
+
+    private bool $enabled = false;
+
+    private bool $captureBacktrace = false;
+
+    /** @var callable|null */
+    private $onSlowQuery = null;
+
+    public function enable(): void
+    {
+        $this->enabled = true;
+    }
+
+    public function disable(): void
+    {
+        $this->enabled = false;
+    }
+
+    public function isEnabled(): bool
+    {
+        return $this->enabled;
+    }
+
+    public function setSlowThreshold(float $milliseconds): void
+    {
+        $this->slowThreshold = $milliseconds;
+    }
+
+    public function enableBacktrace(bool $enabled = true): void
+    {
+        $this->captureBacktrace = $enabled;
+    }
+
+    public function onSlowQuery(callable $callback): void
+    {
+        $this->onSlowQuery = $callback;
+    }
+
+    /**
+     * @param  array<mixed>  $bindings
+     */
+    public function log(string $query, array $bindings, float $durationMs, string $collection = '', string $operation = ''): void
+    {
+        if (! $this->enabled) {
+            return;
+        }
+
+        $backtrace = null;
+        if ($this->captureBacktrace) {
+            $trace = \debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 10);
+            $backtrace = \array_map(
+                fn (array $frame) => ($frame['file'] ?? '') . ':' . ($frame['line'] ?? '') . ' ' . $frame['function'],
+                $trace
+            );
+        }
+
+        $entry = new QueryLog(
+            query: $query,
+            bindings: $bindings,
+            durationMs: $durationMs,
+            collection: $collection,
+            operation: $operation,
+            backtrace: $backtrace,
+        );
+
+        $this->logs[] = $entry;
+
+        if ($durationMs >= $this->slowThreshold && $this->onSlowQuery !== null) {
+            ($this->onSlowQuery)($entry);
+        }
+    }
+
+    /**
+     * @return array<QueryLog>
+     */
+    public function getLogs(): array
+    {
+        return $this->logs;
+    }
+
+    /**
+     * @return array<QueryLog>
+     */
+    public function getSlowQueries(): array
+    {
+        return \array_filter($this->logs, fn (QueryLog $log) => $log->durationMs >= $this->slowThreshold);
+    }
+
+    public function getQueryCount(): int
+    {
+        return \count($this->logs);
+    }
+
+    public function getTotalTime(): float
+    {
+        return \array_sum(\array_map(fn (QueryLog $log) => $log->durationMs, $this->logs));
+    }
+
+    /**
+     * @return array<string, int>
+     */
+    public function detectNPlusOne(int $threshold = 5): array
+    {
+        $patterns = [];
+
+        foreach ($this->logs as $log) {
+            $pattern = \preg_replace('/\?(?:,\s*\?)*/', '?...', $log->query) ?? $log->query;
+            $pattern = \preg_replace('/\'[^\']*\'/', '?', $pattern) ?? $pattern;
+            $pattern = \preg_replace('/\d+/', '?', $pattern) ?? $pattern;
+
+            if (! isset($patterns[$pattern])) {
+                $patterns[$pattern] = 0;
+            }
+
+            $patterns[$pattern]++;
+        }
+
+        return \array_filter($patterns, fn (int $count) => $count >= $threshold);
+    }
+
+    public function reset(): void
+    {
+        $this->logs = [];
+    }
+}
diff --git a/src/Database/Query.php b/src/Database/Query.php
index 147c463ad0..e2b7a46a70 100644
--- a/src/Database/Query.php
+++ b/src/Database/Query.php
@@ -2,427 +2,170 @@
 
 namespace Utopia\Database;
 
-use JsonException;
 use Utopia\Database\Exception\Query as QueryException;
-
-class Query
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Exception as BaseQueryException;
+use Utopia\Query\Method;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Extends the base query library with database-specific query construction, parsing, and grouping.
+ *
+ * @phpstan-consistent-constructor
+ */
+class Query extends BaseQuery
 {
-    // Filter methods
-    public const TYPE_EQUAL = 'equal';
-    public const TYPE_NOT_EQUAL = 'notEqual';
-    public const TYPE_LESSER = 'lessThan';
-    public const TYPE_LESSER_EQUAL = 'lessThanEqual';
-    public const TYPE_GREATER = 'greaterThan';
-    public const TYPE_GREATER_EQUAL = 'greaterThanEqual';
-    public const TYPE_CONTAINS = 'contains';
-    public const TYPE_CONTAINS_ANY = 'containsAny';
-    public const TYPE_NOT_CONTAINS = 'notContains';
-    public const TYPE_SEARCH = 'search';
-    public const TYPE_NOT_SEARCH = 'notSearch';
-    public const TYPE_IS_NULL = 'isNull';
-    public const TYPE_IS_NOT_NULL = 'isNotNull';
-    public const TYPE_BETWEEN = 'between';
-    public const TYPE_NOT_BETWEEN = 'notBetween';
-    public const TYPE_STARTS_WITH = 'startsWith';
-    public const TYPE_NOT_STARTS_WITH = 'notStartsWith';
-    public const TYPE_ENDS_WITH = 'endsWith';
-    public const TYPE_NOT_ENDS_WITH = 'notEndsWith';
-    public const TYPE_REGEX = 'regex';
-    public const TYPE_EXISTS = 'exists';
-    public const TYPE_NOT_EXISTS = 'notExists';
-
-    // Spatial methods
-    public const TYPE_CROSSES = 'crosses';
-    public const TYPE_NOT_CROSSES = 'notCrosses';
-    public const TYPE_DISTANCE_EQUAL = 'distanceEqual';
-    public const TYPE_DISTANCE_NOT_EQUAL = 'distanceNotEqual';
-    public const TYPE_DISTANCE_GREATER_THAN = 'distanceGreaterThan';
-    public const TYPE_DISTANCE_LESS_THAN = 'distanceLessThan';
-    public const TYPE_INTERSECTS = 'intersects';
-    public const TYPE_NOT_INTERSECTS = 'notIntersects';
-    public const TYPE_OVERLAPS = 'overlaps';
-    public const TYPE_NOT_OVERLAPS = 'notOverlaps';
-    public const TYPE_TOUCHES = 'touches';
-    public const TYPE_NOT_TOUCHES = 'notTouches';
-
-    // Vector query methods
-    public const TYPE_VECTOR_DOT = 'vectorDot';
-    public const TYPE_VECTOR_COSINE = 'vectorCosine';
-    public const TYPE_VECTOR_EUCLIDEAN = 'vectorEuclidean';
-
-    public const TYPE_SELECT = 'select';
-
-    // Order methods
-    public const TYPE_ORDER_DESC = 'orderDesc';
-    public const TYPE_ORDER_ASC = 'orderAsc';
-    public const TYPE_ORDER_RANDOM = 'orderRandom';
-
-    // Pagination methods
-    public const TYPE_LIMIT = 'limit';
-    public const TYPE_OFFSET = 'offset';
-    public const TYPE_CURSOR_AFTER = 'cursorAfter';
-    public const TYPE_CURSOR_BEFORE = 'cursorBefore';
-
-    // Logical methods
-    public const TYPE_AND = 'and';
-    public const TYPE_OR = 'or';
-    public const TYPE_CONTAINS_ALL = 'containsAll';
-    public const TYPE_ELEM_MATCH = 'elemMatch';
-    public const DEFAULT_ALIAS = 'main';
-
-    public const TYPES = [
-        self::TYPE_EQUAL,
-        self::TYPE_NOT_EQUAL,
-        self::TYPE_LESSER,
-        self::TYPE_LESSER_EQUAL,
-        self::TYPE_GREATER,
-        self::TYPE_GREATER_EQUAL,
-        self::TYPE_CONTAINS,
-        self::TYPE_CONTAINS_ANY,
-        self::TYPE_NOT_CONTAINS,
-        self::TYPE_SEARCH,
-        self::TYPE_NOT_SEARCH,
-        self::TYPE_IS_NULL,
-        self::TYPE_IS_NOT_NULL,
-        self::TYPE_BETWEEN,
-        self::TYPE_NOT_BETWEEN,
-        self::TYPE_STARTS_WITH,
-        self::TYPE_NOT_STARTS_WITH,
-        self::TYPE_ENDS_WITH,
-        self::TYPE_NOT_ENDS_WITH,
-        self::TYPE_CROSSES,
-        self::TYPE_NOT_CROSSES,
-        self::TYPE_DISTANCE_EQUAL,
-        self::TYPE_DISTANCE_NOT_EQUAL,
-        self::TYPE_DISTANCE_GREATER_THAN,
-        self::TYPE_DISTANCE_LESS_THAN,
-        self::TYPE_INTERSECTS,
-        self::TYPE_NOT_INTERSECTS,
-        self::TYPE_OVERLAPS,
-        self::TYPE_NOT_OVERLAPS,
-        self::TYPE_TOUCHES,
-        self::TYPE_NOT_TOUCHES,
-        self::TYPE_VECTOR_DOT,
-        self::TYPE_VECTOR_COSINE,
-        self::TYPE_VECTOR_EUCLIDEAN,
-        self::TYPE_EXISTS,
-        self::TYPE_NOT_EXISTS,
-        self::TYPE_SELECT,
-        self::TYPE_ORDER_DESC,
-        self::TYPE_ORDER_ASC,
-        self::TYPE_ORDER_RANDOM,
-        self::TYPE_LIMIT,
-        self::TYPE_OFFSET,
-        self::TYPE_CURSOR_AFTER,
-        self::TYPE_CURSOR_BEFORE,
-        self::TYPE_AND,
-        self::TYPE_OR,
-        self::TYPE_CONTAINS_ALL,
-        self::TYPE_ELEM_MATCH,
-        self::TYPE_REGEX
-    ];
-
-    public const VECTOR_TYPES = [
-        self::TYPE_VECTOR_DOT,
-        self::TYPE_VECTOR_COSINE,
-        self::TYPE_VECTOR_EUCLIDEAN,
-    ];
-
-    protected const LOGICAL_TYPES = [
-        self::TYPE_AND,
-        self::TYPE_OR,
-        self::TYPE_ELEM_MATCH,
-    ];
-
-    protected string $method = '';
-    protected string $attribute = '';
-    protected string $attributeType = '';
-    protected bool $onArray = false;
     protected bool $isObjectAttribute = false;
 
     /**
-     * @var array<mixed>
+     * Default table alias used in queries
      */
-    protected array $values = [];
+    public const DEFAULT_ALIAS = 'table_main';
 
     /**
-     * Construct a new query object
+     * Methods that compose child queries and contribute their inner
+     * structure to a shape/fingerprint. Widened from parent's protected
+     * declaration so external validators (Queries.php) can reuse it
+     * without redeclaring the list.
      *
-     * @param string $method
-     * @param string $attribute
-     * @param array<mixed> $values
+     * @var list<Method>
      */
-    public function __construct(string $method, string $attribute = '', array $values = [])
-    {
-        if ($attribute === '' && \in_array($method, [Query::TYPE_ORDER_ASC, Query::TYPE_ORDER_DESC])) {
-            $attribute = '$sequence';
-        }
-
-        $this->method = $method;
-        $this->attribute = $attribute;
-        $this->values = $values;
-    }
+    public const array LOGICAL_TYPES = [Method::And, Method::Or, Method::ElemMatch];
 
-    public function __clone(): void
-    {
-        foreach ($this->values as $index => $value) {
-            if ($value instanceof self) {
-                $this->values[$index] = clone $value;
-            }
-        }
-    }
-
-    /**
-     * @return string
-     */
-    public function getMethod(): string
-    {
-        return $this->method;
-    }
-
-    /**
-     * @return string
-     */
-    public function getAttribute(): string
-    {
-        return $this->attribute;
-    }
-
-    /**
-     * @return array<mixed>
-     */
-    public function getValues(): array
-    {
-        return $this->values;
-    }
-
-    /**
-     * @param mixed $default
-     * @return mixed
-     */
-    public function getValue(mixed $default = null): mixed
-    {
-        return $this->values[0] ?? $default;
-    }
-
-    /**
-     * Sets method
-     *
-     * @param string $method
-     * @return self
-     */
-    public function setMethod(string $method): self
-    {
-        $this->method = $method;
-
-        return $this;
-    }
+    public const TYPE_ELEM_MATCH = 'elemMatch';
 
     /**
-     * Sets attribute
+     * Ceiling on the nodes shape() will walk.
      *
-     * @param string $attribute
-     * @return self
+     * A query tree that reaches this is not one anybody wrote by hand: either a
+     * child points back at an ancestor, which makes the walk unbounded, or the
+     * same child object is shared often enough that the preorder walk visits it
+     * exponentially. The walk deliberately does not deduplicate -- a node
+     * reachable by two paths has to be listed under both, or the reversed pass
+     * would shape a parent before its child -- so the count is what bounds it.
      */
-    public function setAttribute(string $attribute): self
-    {
-        $this->attribute = $attribute;
-
-        return $this;
-    }
+    public const int SHAPE_MAX_NODES = 10000;
 
     /**
-     * Sets values
-     *
-     * @param array<mixed> $values
-     * @return self
+     * @param  array<mixed>  $values
      */
-    public function setValues(array $values): self
+    public function __construct(Method|string $method, string $attribute = '', array $values = [])
     {
-        $this->values = $values;
+        $methodEnum = $method instanceof Method ? $method : Method::from($method);
 
-        return $this;
-    }
-
-    /**
-     * Sets value
-     * @param mixed $value
-     * @return self
-     */
-    public function setValue(mixed $value): self
-    {
-        $this->values = [$value];
+        if ($attribute === '' && \in_array($methodEnum, [Method::OrderAsc, Method::OrderDesc])) {
+            $attribute = Document::SEQUENCE;
+        }
 
-        return $this;
+        parent::__construct($methodEnum, $attribute, $values);
     }
 
     /**
-     * Check if method is supported
-     *
-     * @param string $value
-     * @return bool
+     * @throws QueryException
      */
-    public static function isMethod(string $value): bool
+    public static function parse(string $query, bool $allowRaw = false): static
     {
-        return match ($value) {
-            self::TYPE_EQUAL,
-            self::TYPE_NOT_EQUAL,
-            self::TYPE_LESSER,
-            self::TYPE_LESSER_EQUAL,
-            self::TYPE_GREATER,
-            self::TYPE_GREATER_EQUAL,
-            self::TYPE_CONTAINS,
-            self::TYPE_CONTAINS_ANY,
-            self::TYPE_NOT_CONTAINS,
-            self::TYPE_SEARCH,
-            self::TYPE_NOT_SEARCH,
-            self::TYPE_ORDER_ASC,
-            self::TYPE_ORDER_DESC,
-            self::TYPE_ORDER_RANDOM,
-            self::TYPE_LIMIT,
-            self::TYPE_OFFSET,
-            self::TYPE_CURSOR_AFTER,
-            self::TYPE_CURSOR_BEFORE,
-            self::TYPE_IS_NULL,
-            self::TYPE_IS_NOT_NULL,
-            self::TYPE_BETWEEN,
-            self::TYPE_NOT_BETWEEN,
-            self::TYPE_STARTS_WITH,
-            self::TYPE_NOT_STARTS_WITH,
-            self::TYPE_ENDS_WITH,
-            self::TYPE_NOT_ENDS_WITH,
-            self::TYPE_CROSSES,
-            self::TYPE_NOT_CROSSES,
-            self::TYPE_DISTANCE_EQUAL,
-            self::TYPE_DISTANCE_NOT_EQUAL,
-            self::TYPE_DISTANCE_GREATER_THAN,
-            self::TYPE_DISTANCE_LESS_THAN,
-            self::TYPE_INTERSECTS,
-            self::TYPE_NOT_INTERSECTS,
-            self::TYPE_OVERLAPS,
-            self::TYPE_NOT_OVERLAPS,
-            self::TYPE_TOUCHES,
-            self::TYPE_NOT_TOUCHES,
-            self::TYPE_OR,
-            self::TYPE_AND,
-            self::TYPE_CONTAINS_ALL,
-            self::TYPE_ELEM_MATCH,
-            self::TYPE_SELECT,
-            self::TYPE_VECTOR_DOT,
-            self::TYPE_VECTOR_COSINE,
-            self::TYPE_VECTOR_EUCLIDEAN,
-            self::TYPE_EXISTS,
-            self::TYPE_NOT_EXISTS => true,
-            default => false,
-        };
-    }
+        try {
+            $parsed = parent::parse($query, $allowRaw);
 
-    /**
-     * Check if method is a spatial-only query method
-     * @return bool
-     */
-    public function isSpatialQuery(): bool
-    {
-        return match ($this->method) {
-            self::TYPE_CROSSES,
-            self::TYPE_NOT_CROSSES,
-            self::TYPE_DISTANCE_EQUAL,
-            self::TYPE_DISTANCE_NOT_EQUAL,
-            self::TYPE_DISTANCE_GREATER_THAN,
-            self::TYPE_DISTANCE_LESS_THAN,
-            self::TYPE_INTERSECTS,
-            self::TYPE_NOT_INTERSECTS,
-            self::TYPE_OVERLAPS,
-            self::TYPE_NOT_OVERLAPS,
-            self::TYPE_TOUCHES,
-            self::TYPE_NOT_TOUCHES => true,
-            default => false,
-        };
+            return new static($parsed->getMethod(), $parsed->getAttribute(), $parsed->getValues());
+        } catch (BaseQueryException $e) {
+            throw new QueryException($e->getMessage(), $e->getCode(), $e);
+        }
     }
 
     /**
-     * Parse query
+     * @param  array<string, mixed>  $query
      *
-     * @param string $query
-     * @return self
      * @throws QueryException
      */
-    public static function parse(string $query): self
+    public static function parseQuery(array $query, bool $allowRaw = false): static
     {
         try {
-            $query = \json_decode($query, true, flags: JSON_THROW_ON_ERROR);
-        } catch (\JsonException $e) {
-            throw new QueryException('Invalid query: ' . $e->getMessage());
-        }
+            $parsed = parent::parseQuery(self::decodeNestedValues($query, $allowRaw), $allowRaw);
 
-        if (!\is_array($query)) {
-            throw new QueryException('Invalid query. Must be an array, got ' . \gettype($query));
+            return new static($parsed->getMethod(), $parsed->getAttribute(), $parsed->getValues());
+        } catch (BaseQueryException $e) {
+            throw new QueryException($e->getMessage(), $e->getCode(), $e);
         }
-
-        return self::parseQuery($query);
     }
 
     /**
-     * Parse query
+     * Decode a logical query's children to the array form the parser recurses into.
+     *
+     * Clients may serialise those children as query strings rather than nested
+     * objects. The parser's recursion is typed for arrays and only documented as
+     * such, so a string child reaches it and raises a TypeError, which is not a
+     * QueryException and so escapes every caller that guards for one.
+     *
+     * @param  array<string, mixed>  $query
+     * @return array<string, mixed>
      *
-     * @param array<string, mixed> $query
-     * @return self
      * @throws QueryException
      */
-    public static function parseQuery(array $query): self
+    private static function decodeNestedValues(array $query, bool $allowRaw): array
     {
-        $method = $query['method'] ?? '';
-        $attribute = $query['attribute'] ?? '';
-        $values = $query['values'] ?? [];
+        $method = $query['method'] ?? null;
 
-        if (!\is_string($method)) {
-            throw new QueryException('Invalid query method. Must be a string, got ' . \gettype($method));
+        if (! \is_string($method)) {
+            return $query;
         }
 
-        if (!self::isMethod($method)) {
-            throw new QueryException('Invalid query method: ' . $method);
+        if (! (Method::tryFrom($method)?->isNested() ?? false)) {
+            return $query;
         }
 
-        if (!\is_string($attribute)) {
-            throw new QueryException('Invalid query attribute. Must be a string, got ' . \gettype($attribute));
-        }
+        $values = $query['values'] ?? [];
 
-        if (!\is_array($values)) {
-            throw new QueryException('Invalid query values. Must be an array, got ' . \gettype($values));
+        if (! \is_array($values)) {
+            return $query;
         }
 
-        if (\in_array($method, self::LOGICAL_TYPES)) {
-            foreach ($values as $index => $value) {
-                if (\is_string($value)) {
-                    $values[$index] = self::parse($value);
-                } elseif (\is_array($value)) {
-                    $values[$index] = self::parseQuery($value);
-                } else {
-                    throw new QueryException('Invalid nested query. Must be an array or string, got ' . \gettype($value));
-                }
+        foreach ($values as $index => $value) {
+            if (\is_array($value)) {
+                continue;
+            }
+
+            if (! \is_string($value)) {
+                throw new QueryException('Invalid nested query. Must be an array or string, got '.\gettype($value));
             }
+
+            $values[$index] = self::parse($value, $allowRaw)->toArray();
         }
 
-        return new self($method, $attribute, $values);
+        $query['values'] = $values;
+
+        return $query;
     }
 
     /**
-     * Parse an array of queries
-     *
-     * @param array<string> $queries
-     *
-     * @return array<Query>
-     * @throws QueryException
+     * @param  Document  $value
      */
-    public static function parseQueries(array $queries): array
+    public static function cursorAfter(mixed $value): static
     {
-        $parsed = [];
+        return new static(Method::CursorAfter, values: [$value]);
+    }
 
-        foreach ($queries as $query) {
-            $parsed[] = Query::parse($query);
+    /**
+     * @param  Document  $value
+     */
+    public static function cursorBefore(mixed $value): static
+    {
+        return new static(Method::CursorBefore, values: [$value]);
+    }
+
+    /**
+     * Check if method is supported. Accepts both string and Method enum.
+     */
+    public static function isMethod(Method|string $value): bool
+    {
+        if ($value instanceof Method) {
+            return true;
         }
 
-        return $parsed;
+        return Method::tryFrom($value) !== null;
     }
 
     /**
@@ -476,6 +219,8 @@ public static function fingerprint(array $queries): string
      * always resolved before the node itself.
      *
      * @return string
+     *
+     * @throws QueryException if the tree exceeds self::SHAPE_MAX_NODES
      */
     public function shape(): string
     {
@@ -487,6 +232,10 @@ public function shape(): string
             $node = \array_pop($stack);
             $nodes[] = $node;
 
+            if (\count($nodes) > self::SHAPE_MAX_NODES) {
+                throw new QueryException('Query is too deeply nested to fingerprint: exceeded '.self::SHAPE_MAX_NODES.' nodes, which means a cycle or a child shared across too many parents');
+            }
+
             if (!\in_array($node->method, self::LOGICAL_TYPES, true)) {
                 continue;
             }
@@ -503,7 +252,7 @@ public function shape(): string
             $id = \spl_object_id($node);
 
             if (!\in_array($node->method, self::LOGICAL_TYPES, true)) {
-                $shapes[$id] = $node->method . ':' . $node->attribute;
+                $shapes[$id] = $node->method->value . ':' . $node->attribute;
                 continue;
             }
 
@@ -515,7 +264,7 @@ public function shape(): string
             }
             \sort($childShapes);
             // Attribute is empty for and/or; meaningful for elemMatch (the field being matched).
-            $shapes[$id] = $node->method . ':' . $node->attribute . '(' . \implode('|', $childShapes) . ')';
+            $shapes[$id] = $node->method->value . ':' . $node->attribute . '(' . \implode('|', $childShapes) . ')';
         }
 
         return $shapes[\spl_object_id($this)];
@@ -526,20 +275,25 @@ public function shape(): string
      */
     public function toArray(): array
     {
-        $array = ['method' => $this->method];
+        $array = ['method' => $this->method->value];
 
-        if (!empty($this->attribute)) {
+        if (! empty($this->attribute)) {
             $array['attribute'] = $this->attribute;
         }
 
-        if (\in_array($array['method'], self::LOGICAL_TYPES)) {
+        if (\in_array($this->method, self::LOGICAL_TYPES, true) || $this->method === Method::Having) {
             foreach ($this->values as $index => $value) {
+                if (! $value instanceof self) {
+                    throw new QueryException(
+                        'Invalid child query in '.$this->method->value.' at index '.$index.': expected Query, got '.\get_debug_type($value)
+                    );
+                }
                 $array['values'][$index] = $value->toArray();
             }
         } else {
             $array['values'] = [];
             foreach ($this->values as $value) {
-                if ($value instanceof Document && in_array($this->method, [self::TYPE_CURSOR_AFTER, self::TYPE_CURSOR_BEFORE])) {
+                if ($value instanceof Document && in_array($this->method, [Method::CursorAfter, Method::CursorBefore])) {
                     $value = $value->getId();
                 }
                 $array['values'][] = $value;
@@ -550,838 +304,103 @@ public function toArray(): array
     }
 
     /**
-     * @return string
-     * @throws QueryException
-     */
-    public function toString(): string
-    {
-        try {
-            return \json_encode($this->toArray(), flags: JSON_THROW_ON_ERROR);
-        } catch (JsonException $e) {
-            throw new QueryException('Invalid Json: ' . $e->getMessage());
-        }
-    }
-
-    /**
-     * Helper method to create Query with equal method
+     * Iterates through queries and groups them by type,
+     * returning the result in the Database-specific array format
+     * with string order types and cursor directions.
      *
-     * @param string $attribute
-     * @param array<string|int|float|bool|array<mixed,mixed>> $values
-     * @return Query
-     */
-    public static function equal(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_EQUAL, $attribute, $values);
-    }
-
-    /**
-     * Helper method to create Query with notEqual method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool|array<mixed,mixed> $value
-     * @return Query
-     */
-    public static function notEqual(string $attribute, string|int|float|bool|array $value): self
-    {
-        // maps or not an array
-        if ((is_array($value) && !array_is_list($value)) || !is_array($value)) {
-            $value = [$value];
-        }
-        return new self(self::TYPE_NOT_EQUAL, $attribute, $value);
-    }
-
-    /**
-     * Helper method to create Query with lessThan method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $value
-     * @return Query
-     */
-    public static function lessThan(string $attribute, string|int|float|bool $value): self
-    {
-        return new self(self::TYPE_LESSER, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with lessThanEqual method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $value
-     * @return Query
-     */
-    public static function lessThanEqual(string $attribute, string|int|float|bool $value): self
-    {
-        return new self(self::TYPE_LESSER_EQUAL, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with greaterThan method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $value
-     * @return Query
-     */
-    public static function greaterThan(string $attribute, string|int|float|bool $value): self
-    {
-        return new self(self::TYPE_GREATER, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with greaterThanEqual method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $value
-     * @return Query
-     */
-    public static function greaterThanEqual(string $attribute, string|int|float|bool $value): self
-    {
-        return new self(self::TYPE_GREATER_EQUAL, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with contains method
-     *
-     * @deprecated Use containsAny() for array attributes, or keep using contains() for string substring matching.
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function contains(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_CONTAINS, $attribute, $values);
-    }
-
-    /**
-     * Helper method to create Query with containsAny method.
-     * For array and relationship attributes, matches documents where the attribute contains ANY of the given values.
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function containsAny(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_CONTAINS_ANY, $attribute, $values);
-    }
-
-    /**
-     * Helper method to create Query with notContains method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function notContains(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_NOT_CONTAINS, $attribute, $values);
-    }
-
-    /**
-     * Helper method to create Query with between method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $start
-     * @param string|int|float|bool $end
-     * @return Query
-     */
-    public static function between(string $attribute, string|int|float|bool $start, string|int|float|bool $end): self
-    {
-        return new self(self::TYPE_BETWEEN, $attribute, [$start, $end]);
-    }
-
-    /**
-     * Helper method to create Query with notBetween method
-     *
-     * @param string $attribute
-     * @param string|int|float|bool $start
-     * @param string|int|float|bool $end
-     * @return Query
-     */
-    public static function notBetween(string $attribute, string|int|float|bool $start, string|int|float|bool $end): self
-    {
-        return new self(self::TYPE_NOT_BETWEEN, $attribute, [$start, $end]);
-    }
-
-    /**
-     * Helper method to create Query with search method
-     *
-     * @param string $attribute
-     * @param string $value
-     * @return Query
-     */
-    public static function search(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_SEARCH, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with notSearch method
-     *
-     * @param string $attribute
-     * @param string $value
-     * @return Query
-     */
-    public static function notSearch(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_NOT_SEARCH, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query with select method
-     *
-     * @param array<string> $attributes
-     * @return Query
-     */
-    public static function select(array $attributes): self
-    {
-        return new self(self::TYPE_SELECT, values: $attributes);
-    }
-
-    /**
-     * Helper method to create Query with orderDesc method
-     *
-     * @param string $attribute
-     * @return Query
-     */
-    public static function orderDesc(string $attribute = ''): self
-    {
-        return new self(self::TYPE_ORDER_DESC, $attribute);
-    }
-
-    /**
-     * Helper method to create Query with orderAsc method
-     *
-     * @param string $attribute
-     * @return Query
-     */
-    public static function orderAsc(string $attribute = ''): self
-    {
-        return new self(self::TYPE_ORDER_ASC, $attribute);
-    }
-
-    /**
-     * Helper method to create Query with orderRandom method
-     *
-     * @return Query
-     */
-    public static function orderRandom(): self
-    {
-        return new self(self::TYPE_ORDER_RANDOM);
-    }
-
-    /**
-     * Helper method to create Query with limit method
-     *
-     * @param int $value
-     * @return Query
-     */
-    public static function limit(int $value): self
-    {
-        return new self(self::TYPE_LIMIT, values: [$value]);
-    }
-
-    /**
-     * Helper method to create Query with offset method
-     *
-     * @param int $value
-     * @return Query
-     */
-    public static function offset(int $value): self
-    {
-        return new self(self::TYPE_OFFSET, values: [$value]);
-    }
-
-    /**
-     * Helper method to create Query with cursorAfter method
-     *
-     * @param Document $value
-     * @return Query
-     */
-    public static function cursorAfter(Document $value): self
-    {
-        return new self(self::TYPE_CURSOR_AFTER, values: [$value]);
-    }
-
-    /**
-     * Helper method to create Query with cursorBefore method
-     *
-     * @param Document $value
-     * @return Query
-     */
-    public static function cursorBefore(Document $value): self
-    {
-        return new self(self::TYPE_CURSOR_BEFORE, values: [$value]);
-    }
-
-    /**
-     * Helper method to create Query with isNull method
-     *
-     * @param string $attribute
-     * @return Query
-     */
-    public static function isNull(string $attribute): self
-    {
-        return new self(self::TYPE_IS_NULL, $attribute);
-    }
-
-    /**
-     * Helper method to create Query with isNotNull method
-     *
-     * @param string $attribute
-     * @return Query
-     */
-    public static function isNotNull(string $attribute): self
-    {
-        return new self(self::TYPE_IS_NOT_NULL, $attribute);
-    }
-
-    public static function startsWith(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_STARTS_WITH, $attribute, [$value]);
-    }
-
-    public static function notStartsWith(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_NOT_STARTS_WITH, $attribute, [$value]);
-    }
-
-    public static function endsWith(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_ENDS_WITH, $attribute, [$value]);
-    }
-
-    public static function notEndsWith(string $attribute, string $value): self
-    {
-        return new self(self::TYPE_NOT_ENDS_WITH, $attribute, [$value]);
-    }
-
-    /**
-     * Helper method to create Query for documents created before a specific date
-     *
-     * @param string $value
-     * @return Query
-     */
-    public static function createdBefore(string $value): self
-    {
-        return self::lessThan('$createdAt', $value);
-    }
-
-    /**
-     * Helper method to create Query for documents created after a specific date
-     *
-     * @param string $value
-     * @return Query
-     */
-    public static function createdAfter(string $value): self
-    {
-        return self::greaterThan('$createdAt', $value);
-    }
-
-    /**
-     * Helper method to create Query for documents updated before a specific date
-     *
-     * @param string $value
-     * @return Query
-     */
-    public static function updatedBefore(string $value): self
-    {
-        return self::lessThan('$updatedAt', $value);
-    }
-
-    /**
-     * Helper method to create Query for documents updated after a specific date
-     *
-     * @param string $value
-     * @return Query
-     */
-    public static function updatedAfter(string $value): self
-    {
-        return self::greaterThan('$updatedAt', $value);
-    }
-
-    /**
-     * Helper method to create Query for documents created between two dates
-     *
-     * @param string $start
-     * @param string $end
-     * @return Query
-     */
-    public static function createdBetween(string $start, string $end): self
-    {
-        return self::between('$createdAt', $start, $end);
-    }
-
-    /**
-     * Helper method to create Query for documents updated between two dates
-     *
-     * @param string $start
-     * @param string $end
-     * @return Query
-     */
-    public static function updatedBetween(string $start, string $end): self
-    {
-        return self::between('$updatedAt', $start, $end);
-    }
-
-    /**
-     * @param array<Query> $queries
-     * @return Query
-     */
-    public static function or(array $queries): self
-    {
-        return new self(self::TYPE_OR, '', $queries);
-    }
-
-    /**
-     * @param array<Query> $queries
-     * @return Query
-     */
-    public static function and(array $queries): self
-    {
-        return new self(self::TYPE_AND, '', $queries);
-    }
-
-    /**
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function containsAll(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_CONTAINS_ALL, $attribute, $values);
-    }
-
-    /**
-     * Filters $queries for $types
-     *
-     * @param array<Query> $queries
-     * @param array<string> $types
-     * @param bool $clone
-     * @return array<Query>
-     */
-    public static function getByType(array $queries, array $types, bool $clone = true): array
-    {
-        $filtered = [];
-
-        foreach ($queries as $query) {
-            if (\in_array($query->getMethod(), $types, true)) {
-                $filtered[] = $clone ? clone $query : $query;
-            }
-        }
-
-        return $filtered;
-    }
-
-    /**
      * @param  array<Query>  $queries
-     * @param bool $clone
-     * @return array<Query>
-     */
-    public static function getCursorQueries(array $queries, bool $clone = true): array
-    {
-        return self::getByType(
-            $queries,
-            [
-                Query::TYPE_CURSOR_AFTER,
-                Query::TYPE_CURSOR_BEFORE,
-            ],
-            $clone
-        );
-    }
-
-    /**
-     * Iterates through queries are groups them by type
-     *
-     * @param array<Query> $queries
      * @return array{
      *     filters: array<Query>,
      *     selections: array<Query>,
+     *     aggregations: array<Query>,
+     *     groupBy: array<string>,
+     *     having: array<Query>,
+     *     joins: array<Query>,
+     *     distinct: bool,
      *     limit: int|null,
      *     offset: int|null,
      *     orderAttributes: array<string>,
-     *     orderTypes: array<string>,
+     *     orderTypes: array<OrderDirection>,
      *     cursor: Document|null,
-     *     cursorDirection: string|null
+     *     cursorDirection: CursorDirection|null
      * }
      */
-    public static function groupByType(array $queries): array
-    {
-        $filters = [];
-        $selections = [];
-        $limit = null;
-        $offset = null;
+    public static function groupForDatabase(array $queries): array
+    {
+        $grouped = parent::groupByType($queries);
+
+        /** @var array<Query> $filters */
+        $filters = $grouped->filters;
+        /** @var array<Query> $selections */
+        $selections = $grouped->selections;
+        /** @var array<Query> $aggregations */
+        $aggregations = $grouped->aggregations;
+        /** @var array<Query> $having */
+        $having = $grouped->having;
+        /** @var array<Query> $joins */
+        $joins = $grouped->joins;
+        /** @var Document|null $cursor */
+        $cursor = $grouped->cursor;
+
+        // The base library's groupByType no longer tracks order attributes on
+        // ParsedQuery — order clauses are consumed directly by the compiler.
+        // Database adapters still take orderAttributes/orderTypes, so rebuild
+        // them here from the pending query list.
         $orderAttributes = [];
         $orderTypes = [];
-        $cursor = null;
-        $cursorDirection = null;
-
         foreach ($queries as $query) {
-            if (!$query instanceof Query) {
+            $direction = match ($query->getMethod()) {
+                Method::OrderAsc => OrderDirection::Asc,
+                Method::OrderDesc => OrderDirection::Desc,
+                Method::OrderRandom => OrderDirection::Random,
+                default => null,
+            };
+
+            if ($direction === null) {
                 continue;
             }
 
-            $method = $query->getMethod();
-            $attribute = $query->getAttribute();
-            $values = $query->getValues();
-
-            switch ($method) {
-                case Query::TYPE_ORDER_ASC:
-                case Query::TYPE_ORDER_DESC:
-                case Query::TYPE_ORDER_RANDOM:
-                    if (!empty($attribute)) {
-                        $orderAttributes[] = $attribute;
-                    }
-
-                    $orderTypes[] = match ($method) {
-                        Query::TYPE_ORDER_ASC => Database::ORDER_ASC,
-                        Query::TYPE_ORDER_DESC => Database::ORDER_DESC,
-                        Query::TYPE_ORDER_RANDOM => Database::ORDER_RANDOM,
-                    };
-
-                    break;
-                case Query::TYPE_LIMIT:
-                    // Keep the 1st limit encountered and ignore the rest
-                    if ($limit !== null) {
-                        break;
-                    }
-
-                    $limit = $values[0] ?? $limit;
-                    break;
-                case Query::TYPE_OFFSET:
-                    // Keep the 1st offset encountered and ignore the rest
-                    if ($offset !== null) {
-                        break;
-                    }
-
-                    $offset = $values[0] ?? $limit;
-                    break;
-                case Query::TYPE_CURSOR_AFTER:
-                case Query::TYPE_CURSOR_BEFORE:
-                    // Keep the 1st cursor encountered and ignore the rest
-                    if ($cursor !== null) {
-                        break;
-                    }
-
-                    $cursor = $values[0] ?? $limit;
-                    $cursorDirection = $method === Query::TYPE_CURSOR_AFTER ? Database::CURSOR_AFTER : Database::CURSOR_BEFORE;
-                    break;
-
-                case Query::TYPE_SELECT:
-                    $selections[] = clone $query;
-                    break;
-
-                default:
-                    $filters[] = clone $query;
-                    break;
-            }
+            $orderAttributes[] = $query->getAttribute();
+            $orderTypes[] = $direction;
         }
+        /** @var list<string> $groupBy */
+        $groupBy = $grouped->groupBy;
 
         return [
             'filters' => $filters,
             'selections' => $selections,
-            'limit' => $limit,
-            'offset' => $offset,
+            'aggregations' => $aggregations,
+            'groupBy' => $groupBy,
+            'having' => $having,
+            'joins' => $joins,
+            'distinct' => $grouped->distinct,
+            'limit' => $grouped->limit,
+            'offset' => $grouped->offset,
             'orderAttributes' => $orderAttributes,
             'orderTypes' => $orderTypes,
             'cursor' => $cursor,
-            'cursorDirection' => $cursorDirection,
+            'cursorDirection' => $grouped->cursorDirection,
         ];
     }
 
     /**
-     * Is this query able to contain other queries
+     * Check whether this query targets a spatial attribute type (point, linestring, or polygon).
      *
-     * @return bool
-     */
-    public function isNested(): bool
-    {
-        if (in_array($this->getMethod(), self::LOGICAL_TYPES)) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * @return bool
-     */
-    public function onArray(): bool
-    {
-        return $this->onArray;
-    }
-
-    /**
-     * @param bool $bool
-     * @return void
-     */
-    public function setOnArray(bool $bool): void
-    {
-        $this->onArray = $bool;
-    }
-
-    /**
-     * @param string $type
-     * @return void
-     */
-    public function setAttributeType(string $type): void
-    {
-        $this->attributeType = $type;
-    }
-
-    /**
-     * @return string
-     */
-    public function getAttributeType(): string
-    {
-        return $this->attributeType;
-    }
-    /**
-     * @return bool
+     * @return bool True if the attribute type is spatial.
      */
     public function isSpatialAttribute(): bool
     {
-        return in_array($this->attributeType, Database::SPATIAL_TYPES);
-    }
-
-    /**
-     * @return bool
-     */
-    public function isObjectAttribute(): bool
-    {
-        return $this->attributeType === Database::VAR_OBJECT;
-    }
-
-    // Spatial query methods
-
-    /**
-     * Helper method to create Query with distanceEqual method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param int|float $distance
-     * @param bool $meters
-     * @return Query
-     */
-    public static function distanceEqual(string $attribute, array $values, int|float $distance, bool $meters = false): self
-    {
-        return new self(self::TYPE_DISTANCE_EQUAL, $attribute, [[$values,$distance,$meters]]);
-    }
-
-    /**
-     * Helper method to create Query with distanceNotEqual method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param int|float $distance
-     * @param bool $meters
-     * @return Query
-     */
-    public static function distanceNotEqual(string $attribute, array $values, int|float $distance, bool $meters = false): self
-    {
-        return new self(self::TYPE_DISTANCE_NOT_EQUAL, $attribute, [[$values,$distance,$meters]]);
-    }
-
-    /**
-     * Helper method to create Query with distanceGreaterThan method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param int|float $distance
-     * @param bool $meters
-     * @return Query
-     */
-    public static function distanceGreaterThan(string $attribute, array $values, int|float $distance, bool $meters = false): self
-    {
-        return new self(self::TYPE_DISTANCE_GREATER_THAN, $attribute, [[$values,$distance, $meters]]);
-    }
-
-    /**
-     * Helper method to create Query with distanceLessThan method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param int|float $distance
-     * @param bool $meters
-     * @return Query
-     */
-    public static function distanceLessThan(string $attribute, array $values, int|float $distance, bool $meters = false): self
-    {
-        return new self(self::TYPE_DISTANCE_LESS_THAN, $attribute, [[$values,$distance,$meters]]);
-    }
-
-    /**
-     * Helper method to create Query with intersects method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function intersects(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_INTERSECTS, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with notIntersects method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function notIntersects(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_NOT_INTERSECTS, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with crosses method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function crosses(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_CROSSES, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with notCrosses method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function notCrosses(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_NOT_CROSSES, $attribute, [$values]);
+        $type = ColumnType::tryFrom($this->attributeType);
+        return in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true);
     }
 
     /**
-     * Helper method to create Query with overlaps method
+     * Check whether this query targets an object (JSON/hashmap) attribute type.
      *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
+     * @return bool True if the attribute type is object.
      */
-    public static function overlaps(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_OVERLAPS, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with notOverlaps method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function notOverlaps(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_NOT_OVERLAPS, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with touches method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function touches(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_TOUCHES, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with notTouches method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    public static function notTouches(string $attribute, array $values): self
-    {
-        return new self(self::TYPE_NOT_TOUCHES, $attribute, [$values]);
-    }
-
-    /**
-     * Helper method to create Query with vectorDot method
-     *
-     * @param string $attribute
-     * @param array<float> $vector
-     * @return Query
-     */
-    public static function vectorDot(string $attribute, array $vector): self
-    {
-        return new self(self::TYPE_VECTOR_DOT, $attribute, [$vector]);
-    }
-
-    /**
-     * Helper method to create Query with vectorCosine method
-     *
-     * @param string $attribute
-     * @param array<float> $vector
-     * @return Query
-     */
-    public static function vectorCosine(string $attribute, array $vector): self
-    {
-        return new self(self::TYPE_VECTOR_COSINE, $attribute, [$vector]);
-    }
-
-    /**
-     * Helper method to create Query with vectorEuclidean method
-     *
-     * @param string $attribute
-     * @param array<float> $vector
-     * @return Query
-     */
-    public static function vectorEuclidean(string $attribute, array $vector): self
-    {
-        return new self(self::TYPE_VECTOR_EUCLIDEAN, $attribute, [$vector]);
-    }
-
-    /**
-     * Helper method to create Query with regex method
-     *
-     * @param string $attribute
-     * @param string $pattern
-     * @return Query
-     */
-    public static function regex(string $attribute, string $pattern): self
-    {
-        return new self(self::TYPE_REGEX, $attribute, [$pattern]);
-    }
-
-    /**
-     * Helper method to create Query with exists method
-     *
-     * @param array<string> $attributes
-     * @return Query
-     */
-    public static function exists(array $attributes): self
-    {
-        return new self(self::TYPE_EXISTS, '', $attributes);
-    }
-
-    /**
-     * Helper method to create Query with notExists method
-     *
-     * @param string|int|float|bool|array<mixed,mixed> $attribute
-     * @return Query
-     */
-    public static function notExists(string|int|float|bool|array $attribute): self
-    {
-        return new self(self::TYPE_NOT_EXISTS, '', is_array($attribute) ? $attribute : [$attribute]);
-    }
-
-    /**
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @return Query
-     */
-    public static function elemMatch(string $attribute, array $queries): self
+    public function isObjectAttribute(): bool
     {
-        return new self(self::TYPE_ELEM_MATCH, $attribute, $queries);
+        return ColumnType::tryFrom($this->attributeType) === ColumnType::Object;
     }
 }
diff --git a/src/Database/RelationSide.php b/src/Database/RelationSide.php
new file mode 100644
index 0000000000..1c0abacbd1
--- /dev/null
+++ b/src/Database/RelationSide.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines which side of a relationship a collection is on.
+ */
+enum RelationSide: string
+{
+    case Parent = 'parent';
+    case Child = 'child';
+}
diff --git a/src/Database/RelationType.php b/src/Database/RelationType.php
new file mode 100644
index 0000000000..fafdad7129
--- /dev/null
+++ b/src/Database/RelationType.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the cardinality types for relationships between collections.
+ */
+enum RelationType: string
+{
+    case OneToOne = 'oneToOne';
+    case OneToMany = 'oneToMany';
+    case ManyToOne = 'manyToOne';
+    case ManyToMany = 'manyToMany';
+}
diff --git a/src/Database/Relationship.php b/src/Database/Relationship.php
new file mode 100644
index 0000000000..bacd02f67b
--- /dev/null
+++ b/src/Database/Relationship.php
@@ -0,0 +1,356 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+/**
+ * Represents a relationship between two database collections, including its type, direction, and delete behavior.
+ *
+ * @property string $collection
+ * @property string $relatedCollection
+ * @property RelationType $type
+ * @property bool $twoWay
+ * @property string $key
+ * @property string $twoWayKey
+ * @property ForeignKeyAction $onDelete
+ * @property RelationSide $side
+ */
+class Relationship extends Document
+{
+    public function __construct(
+        string $collection,
+        string $relatedCollection,
+        RelationType $type,
+        bool $twoWay = false,
+        string $key = '',
+        string $twoWayKey = '',
+        ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        RelationSide $side = RelationSide::Parent,
+    ) {
+        parent::__construct([
+            self::ID => $key,
+            'key' => $key,
+            'collection' => $collection,
+            'relatedCollection' => $relatedCollection,
+            'relationType' => $type->value,
+            'twoWay' => $twoWay,
+            'twoWayKey' => $twoWayKey,
+            'onDelete' => $onDelete->value,
+            'side' => $side->value,
+        ]);
+    }
+
+    /**
+     * @return (
+     *     $name is 'collection' ? string :
+     *     $name is 'relatedCollection' ? string :
+     *     $name is 'type' ? RelationType :
+     *     $name is 'twoWay' ? bool :
+     *     $name is 'key' ? string :
+     *     $name is 'twoWayKey' ? string :
+     *     $name is 'onDelete' ? ForeignKeyAction :
+     *     $name is 'side' ? RelationSide :
+     *     mixed
+     * )
+     */
+    public function __get(string $name): mixed
+    {
+        switch ($name) {
+            case 'collection':
+                /** @var string $collection */
+                $collection = $this->getAttribute('collection', '');
+
+                return $collection;
+            case 'relatedCollection':
+                /** @var string $relatedCollection */
+                $relatedCollection = $this->getAttribute('relatedCollection', '');
+
+                return $relatedCollection;
+            case 'type':
+                $type = $this->getAttribute('relationType', RelationType::OneToOne->value);
+                if ($type instanceof RelationType) {
+                    return $type;
+                }
+
+                return RelationType::from(\is_string($type) ? $type : RelationType::OneToOne->value);
+            case 'twoWay':
+                return (bool) $this->getAttribute('twoWay', false);
+            case 'key':
+                /** @var string $key */
+                $key = $this->getAttribute('key', $this->getId());
+
+                return $key;
+            case 'twoWayKey':
+                /** @var string $twoWayKey */
+                $twoWayKey = $this->getAttribute('twoWayKey', '');
+
+                return $twoWayKey;
+            case 'onDelete':
+                $onDelete = $this->getAttribute('onDelete', ForeignKeyAction::Restrict->value);
+                if ($onDelete instanceof ForeignKeyAction) {
+                    return $onDelete;
+                }
+
+                return ForeignKeyAction::from(\is_string($onDelete) ? $onDelete : ForeignKeyAction::Restrict->value);
+            case 'side':
+                $side = $this->getAttribute('side', RelationSide::Parent->value);
+                if ($side instanceof RelationSide) {
+                    return $side;
+                }
+
+                return RelationSide::from(\is_string($side) ? $side : RelationSide::Parent->value);
+            default:
+                return $this->getAttribute($name);
+        }
+    }
+
+    public function __set(string $name, mixed $value): void
+    {
+        match ($name) {
+            'collection' => $this->setAttribute('collection', $value),
+            'relatedCollection' => $this->setAttribute('relatedCollection', $value),
+            'type' => $this->setAttribute('relationType', $value instanceof RelationType ? $value->value : $value),
+            'twoWay' => $this->setAttribute('twoWay', $value),
+            'key' => $this->setAttribute('key', $value)->setAttribute(self::ID, $value),
+            'twoWayKey' => $this->setAttribute('twoWayKey', $value),
+            'onDelete' => $this->setAttribute('onDelete', $value instanceof ForeignKeyAction ? $value->value : $value),
+            'side' => $this->setAttribute('side', $value instanceof RelationSide ? $value->value : $value),
+            default => $this->setAttribute($name, $value),
+        };
+    }
+
+    public function __isset(string $name): bool
+    {
+        return match ($name) {
+            'collection', 'relatedCollection', 'type', 'twoWay', 'key', 'twoWayKey', 'onDelete', 'side' => true,
+            default => $this->offsetExists($name),
+        };
+    }
+
+    public static function oneToOne(
+        string $collection,
+        string $relatedCollection,
+        bool $twoWay = false,
+        string $key = '',
+        string $twoWayKey = '',
+        ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        RelationSide $side = RelationSide::Parent,
+    ): self {
+        return new self(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: RelationType::OneToOne,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete,
+            side: $side,
+        );
+    }
+
+    public static function oneToMany(
+        string $collection,
+        string $relatedCollection,
+        bool $twoWay = false,
+        string $key = '',
+        string $twoWayKey = '',
+        ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        RelationSide $side = RelationSide::Parent,
+    ): self {
+        return new self(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: RelationType::OneToMany,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete,
+            side: $side,
+        );
+    }
+
+    public static function manyToOne(
+        string $collection,
+        string $relatedCollection,
+        bool $twoWay = false,
+        string $key = '',
+        string $twoWayKey = '',
+        ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        RelationSide $side = RelationSide::Parent,
+    ): self {
+        return new self(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: RelationType::ManyToOne,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete,
+            side: $side,
+        );
+    }
+
+    public static function manyToMany(
+        string $collection,
+        string $relatedCollection,
+        bool $twoWay = false,
+        string $key = '',
+        string $twoWayKey = '',
+        ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        RelationSide $side = RelationSide::Parent,
+    ): self {
+        return new self(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: RelationType::ManyToMany,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete,
+            side: $side,
+        );
+    }
+
+    /**
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        return new Document([
+            'relatedCollection' => $this->relatedCollection,
+            'relationType' => $this->type->value,
+            'twoWay' => $this->twoWay,
+            'twoWayKey' => $this->twoWayKey,
+            'onDelete' => $this->onDelete->value,
+            'side' => $this->side->value,
+        ]);
+    }
+
+    /**
+     * @param  array<string, mixed>  $data
+     */
+    public static function fromArray(array $data): self
+    {
+        $options = $data['options'] ?? [];
+        if ($options instanceof Document) {
+            $options = $options->getArrayCopy();
+        }
+        if (! \is_array($options)) {
+            $options = [];
+        }
+
+        /** @var string $key */
+        $key = $data[self::ID] ?? $data['key'] ?? '';
+        /** @var string $collection */
+        $collection = $data['collection'] ?? '';
+        /** @var string $relatedCollection */
+        $relatedCollection = $data['relatedCollection'] ?? $options['relatedCollection'] ?? '';
+        /** @var RelationType|string $type */
+        $type = $data['relationType'] ?? $options['relationType'] ?? RelationType::OneToOne->value;
+        /** @var bool $twoWay */
+        $twoWay = $data['twoWay'] ?? $options['twoWay'] ?? false;
+        /** @var string $twoWayKey */
+        $twoWayKey = $data['twoWayKey'] ?? $options['twoWayKey'] ?? '';
+        /** @var ForeignKeyAction|string $onDelete */
+        $onDelete = $data['onDelete'] ?? $options['onDelete'] ?? ForeignKeyAction::Restrict;
+        /** @var RelationSide|string $side */
+        $side = $data['side'] ?? $options['side'] ?? RelationSide::Parent;
+
+        $relationship = self::make(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: $type instanceof RelationType ? $type : RelationType::from((string) $type),
+            twoWay: (bool) $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete instanceof ForeignKeyAction ? $onDelete : ForeignKeyAction::from((string) $onDelete),
+            side: $side instanceof RelationSide ? $side : RelationSide::from((string) $side),
+        );
+
+        foreach ($data as $name => $value) {
+            if (\in_array($name, [
+                self::ID,
+                'key',
+                'collection',
+                'relatedCollection',
+                'relationType',
+                'twoWay',
+                'twoWayKey',
+                'onDelete',
+                'side',
+                'options',
+            ], true)) {
+                continue;
+            }
+            $relationship->setAttribute($name, $value);
+        }
+
+        return $relationship;
+    }
+
+    /**
+     * Create a Relationship instance from a collection ID and attribute Document.
+     *
+     * @param string $collection The parent collection ID
+     * @param Attribute|Document $attribute The relationship attribute
+     * @return self
+     */
+    public static function fromDocument(string $collection, Attribute|Document $attribute): self
+    {
+        $data = $attribute->getArrayCopy();
+        $data['collection'] = $collection;
+
+        return self::fromArray($data);
+    }
+
+    private static function make(
+        string $collection,
+        string $relatedCollection,
+        RelationType $type,
+        bool $twoWay,
+        string $key,
+        string $twoWayKey,
+        ForeignKeyAction $onDelete,
+        RelationSide $side,
+    ): self {
+        return match ($type) {
+            RelationType::OneToOne => self::oneToOne(
+                collection: $collection,
+                relatedCollection: $relatedCollection,
+                twoWay: $twoWay,
+                key: $key,
+                twoWayKey: $twoWayKey,
+                onDelete: $onDelete,
+                side: $side,
+            ),
+            RelationType::OneToMany => self::oneToMany(
+                collection: $collection,
+                relatedCollection: $relatedCollection,
+                twoWay: $twoWay,
+                key: $key,
+                twoWayKey: $twoWayKey,
+                onDelete: $onDelete,
+                side: $side,
+            ),
+            RelationType::ManyToOne => self::manyToOne(
+                collection: $collection,
+                relatedCollection: $relatedCollection,
+                twoWay: $twoWay,
+                key: $key,
+                twoWayKey: $twoWayKey,
+                onDelete: $onDelete,
+                side: $side,
+            ),
+            RelationType::ManyToMany => self::manyToMany(
+                collection: $collection,
+                relatedCollection: $relatedCollection,
+                twoWay: $twoWay,
+                key: $key,
+                twoWayKey: $twoWayKey,
+                onDelete: $onDelete,
+                side: $side,
+            ),
+        };
+    }
+}
diff --git a/src/Database/SetType.php b/src/Database/SetType.php
new file mode 100644
index 0000000000..ef8ea0b406
--- /dev/null
+++ b/src/Database/SetType.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Utopia\Database;
+
+/**
+ * Defines the modes for setting attribute values on a document.
+ */
+enum SetType: string
+{
+    case Assign = 'assign';
+    case Prepend = 'prepend';
+    case Append = 'append';
+}
diff --git a/src/Database/Storage.php b/src/Database/Storage.php
new file mode 100644
index 0000000000..14beb8acb8
--- /dev/null
+++ b/src/Database/Storage.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Utopia\Database;
+
+final readonly class Storage
+{
+    public const string UID = '_uid';
+
+    public const string SEQUENCE = '_id';
+
+    public const string COLLECTION = '_collection';
+
+    public const string TENANT = '_tenant';
+
+    public const string CREATED_AT = '_createdAt';
+
+    public const string UPDATED_AT = '_updatedAt';
+
+    public const string PERMISSIONS = '_permissions';
+
+    public const string VERSION = '_version';
+
+    public const string DISTANCE = '_distance';
+
+    public const string DELETED_AT = '_deletedAt';
+
+    public const string PERMS_SUFFIX = '_perms';
+
+    public const string PERM_DOCUMENT = '_document';
+
+    public const string PERM_TYPE = '_type';
+
+    public const string PERM_PERMISSION = '_permission';
+
+    public const string INDEX_PRIMARY = 'primary';
+
+    public const string INDEX_CREATED_AT = '_created_at';
+
+    public const string INDEX_UPDATED_AT = '_updated_at';
+
+    public const string INDEX_TENANT_ID = '_tenant_id';
+
+    public const string INDEX_1 = '_index1';
+
+    public const string INDEX_PERMISSIONS_ID = '_permissions_id';
+
+    /**
+     * @var array<string, string>
+     */
+    private const array ATTRIBUTE_MAP = [
+        Document::ID => self::UID,
+        Document::SEQUENCE => self::SEQUENCE,
+        Document::COLLECTION => self::COLLECTION,
+        Document::TENANT => self::TENANT,
+        Document::CREATED_AT => self::CREATED_AT,
+        Document::UPDATED_AT => self::UPDATED_AT,
+        Document::DELETED_AT => self::DELETED_AT,
+        Document::PERMISSIONS => self::PERMISSIONS,
+        Document::VERSION => self::VERSION,
+        Document::DISTANCE => self::DISTANCE,
+    ];
+
+    private function __construct()
+    {
+    }
+
+    public static function column(string $attribute): string
+    {
+        return self::ATTRIBUTE_MAP[$attribute] ?? $attribute;
+    }
+
+    public static function attribute(string $column): string
+    {
+        return self::columnMap()[$column] ?? $column;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public static function attributeMap(): array
+    {
+        return self::ATTRIBUTE_MAP;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public static function columnMap(): array
+    {
+        return \array_flip(self::ATTRIBUTE_MAP);
+    }
+
+    public static function permissionsTable(string $collection): string
+    {
+        return $collection.self::PERMS_SUFFIX;
+    }
+}
diff --git a/src/Database/Traits/Async.php b/src/Database/Traits/Async.php
new file mode 100644
index 0000000000..6fe8cab547
--- /dev/null
+++ b/src/Database/Traits/Async.php
@@ -0,0 +1,112 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Throwable;
+use Utopia\Async\Parallel;
+use Utopia\Async\Promise;
+
+/**
+ * Provides concurrent and parallel execution primitives for I/O-bound and CPU-bound tasks.
+ */
+trait Async
+{
+    /**
+     * Run I/O-bound tasks concurrently via coroutines (Promise).
+     *
+     * Coroutines yield on I/O (database queries, network calls), allowing
+     * other tasks to progress on the same thread. No benefit for CPU-bound work.
+     *
+     * @param  array<callable>  $tasks
+     * @return array<mixed> Results in same order as input tasks
+     */
+    protected function promise(array $tasks): array
+    {
+        if (\count($tasks) <= 1) {
+            return \array_map(fn (callable $task) => $task(), $tasks);
+        }
+
+        /** @var array<mixed> $results */
+        $results = Promise::map($tasks)->await();
+
+        return $results;
+    }
+
+    /**
+     * Like promise() but settles all tasks regardless of individual failures.
+     *
+     * Returns null for failed tasks instead of throwing.
+     * Useful for write hooks where one failure shouldn't block others.
+     *
+     * @param  array<callable>  $tasks
+     * @return array<mixed> Results in same order as input tasks (null for failed tasks)
+     */
+    protected function promiseSettled(array $tasks): array
+    {
+        if (\count($tasks) <= 1) {
+            return \array_map(function (callable $task) {
+                try {
+                    return $task();
+                } catch (Throwable) {
+                    return;
+                }
+            }, $tasks);
+        }
+
+        $promises = \array_map(
+            fn (callable $task) => Promise::async($task),
+            $tasks
+        );
+
+        /** @var array<array{status: string, value?: mixed, reason?: mixed}> $settlements */
+        $settlements = Promise::allSettled($promises)->await();
+
+        return \array_map(
+            fn (array $s) => $s['status'] === 'fulfilled' ? ($s['value'] ?? null) : null,
+            $settlements
+        );
+    }
+
+    /**
+     * Run CPU-bound tasks in parallel via threads/processes (Parallel).
+     *
+     * Tasks execute on separate CPU cores for true parallelism.
+     * Falls back to sequential execution when no parallel runtime is available.
+     *
+     * @param  array<callable>  $tasks
+     * @return array<mixed> Results in same order as input tasks
+     */
+    protected function parallel(array $tasks): array
+    {
+        if (\count($tasks) <= 1) {
+            return \array_map(fn (callable $task) => $task(), $tasks);
+        }
+
+        /** @var array<mixed> $results */
+        $results = Parallel::all($tasks);
+
+        return $results;
+    }
+
+    /**
+     * Map a callback over items in parallel via threads/processes.
+     *
+     * More ergonomic than parallel() for batch transformations.
+     * Automatically chunks work across available CPU cores.
+     *
+     * @param  array<mixed>  $items
+     * @param  callable  $callback  fn($item, $index) => mixed
+     * @return array<mixed> Results in same order as input items
+     */
+    protected function parallelMap(array $items, callable $callback): array
+    {
+        if (\count($items) <= 1) {
+            return \array_map($callback, $items, \array_keys($items));
+        }
+
+        /** @var array<mixed> $results */
+        $results = Parallel::map($items, $callback);
+
+        return $results;
+    }
+}
diff --git a/src/Database/Traits/Attributes.php b/src/Database/Traits/Attributes.php
new file mode 100644
index 0000000000..15208b1fdc
--- /dev/null
+++ b/src/Database/Traits/Attributes.php
@@ -0,0 +1,1450 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Exception;
+use Throwable;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Exception\Dependency as DependencyException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Index as IndexException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
+use Utopia\Database\SetType;
+use Utopia\Database\Validator\Attribute as AttributeValidator;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Database\Validator\Index as IndexValidator;
+use Utopia\Database\Validator\IndexDependency as IndexDependencyValidator;
+use Utopia\Database\Validator\Structure;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Provides CRUD operations for collection attributes including creation, update, rename, and deletion.
+ */
+trait Attributes
+{
+    /**
+     * Create Attribute
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  Attribute  $attribute  The attribute definition to create
+     * @return bool True if the attribute was created successfully
+     *
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws Exception
+     */
+    public function createAttribute(string $collection, Attribute $attribute): bool
+    {
+        $id = $attribute->key;
+        $type = $attribute->type;
+        $size = $attribute->size;
+        $required = $attribute->required;
+        $default = $attribute->default;
+        $signed = $attribute->signed;
+        $array = $attribute->array;
+        $format = $attribute->format;
+        $formatOptions = $attribute->formatOptions;
+        $filters = $attribute->filters;
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if (in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon, ColumnType::Vector, ColumnType::Object], true)) {
+            $filters[] = $type->value;
+            $filters = array_unique($filters);
+            $attribute->filters = $filters;
+            $attribute->setAttribute('filters', $filters);
+        }
+
+        $existsInSchema = false;
+
+        $schemaAttributes = $this->adapter->hasFeature(Feature\SchemaAttributes::class)
+            ? $this->getSchemaAttributes($collection->getId())
+            : [];
+
+        try {
+            $attribute = $this->validateAttribute(
+                $collection,
+                $id,
+                $type->value,
+                $size,
+                $required,
+                $default,
+                $signed,
+                $array,
+                $format,
+                $formatOptions,
+                $filters,
+                $schemaAttributes
+            );
+        } catch (DuplicateException $e) {
+            // If the column exists in the physical schema but not in collection
+            // metadata, this is recovery from a partial failure where the column
+            // was created but metadata wasn't updated. Allow re-creation by
+            // skipping physical column creation and proceeding to metadata update.
+            // checkDuplicateId (metadata) runs before checkDuplicateInSchema, so
+            // if the attribute is absent from metadata the duplicate is in the
+            // physical schema only — a recoverable partial-failure state.
+            $existsInMetadata = false;
+            /** @var array<Attribute> $checkAttrs */
+            $checkAttrs = $collection->getAttribute('attributes', []);
+            foreach ($checkAttrs as $attr) {
+                if (\strtolower($attr->key) === \strtolower($id)) {
+                    $existsInMetadata = true;
+                    break;
+                }
+            }
+
+            if ($existsInMetadata) {
+                throw $e;
+            }
+
+            // Check if the existing schema column matches the requested type.
+            // If it matches we can skip column creation. If not, drop the
+            // orphaned column so it gets recreated with the correct type.
+            $typesMatch = true;
+            $expectedColumnType = $this->adapter->hasFeature(Feature\ColumnTypes::class)
+                ? $this->adapter->getColumnType($type->value, $size, $signed, $array, $required)
+                : '';
+            if ($expectedColumnType !== '') {
+                $filteredId = $this->adapter->filter($id);
+                foreach ($schemaAttributes as $schemaAttr) {
+                    $schemaId = $schemaAttr->getId();
+                    if (\strtolower($schemaId) === \strtolower($filteredId)) {
+                        $rawColumnType = $schemaAttr->getAttribute('columnType', '');
+                        $actualColumnType = \strtoupper(\is_string($rawColumnType) ? $rawColumnType : '');
+                        if ($actualColumnType !== \strtoupper($expectedColumnType)) {
+                            $typesMatch = false;
+                        }
+                        break;
+                    }
+                }
+            }
+
+            if (! $typesMatch) {
+                // Column exists with wrong type and is not tracked in metadata,
+                // so no indexes or relationships reference it. Drop and recreate.
+                $this->adapter->deleteAttribute($collection->getId(), $id);
+            } else {
+                $existsInSchema = true;
+            }
+
+        }
+
+        $created = false;
+
+        if (! $existsInSchema) {
+            try {
+                $created = $this->adapter->createAttribute($collection->getId(), $attribute);
+
+                if (! $created) {
+                    throw new DatabaseException('Failed to create attribute');
+                }
+            } catch (DuplicateException) {
+                // Attribute not in metadata (orphan detection above confirmed this).
+                // A DuplicateException from the adapter means the column exists only
+                // in physical schema — suppress and proceed to metadata update.
+            }
+        }
+
+        $collection->setAttribute('attributes', $attribute, SetType::Append);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->cleanupAttribute($collection->getId(), $id),
+            shouldRollback: $created,
+            operationDescription: "attribute creation '{$id}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
+
+        $this->triggerHooks(Event::DocumentPurge, new Document([
+            Document::ID => $collection->getId(),
+            Document::COLLECTION => self::METADATA,
+        ]));
+
+        $this->triggerHooks(
+            Event::AttributeCreate,
+            $attribute->toDocument()->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    /**
+     * Create Attributes
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Attribute>  $attributes  The attribute definitions to create
+     * @return bool True if the attributes were created successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws StructureException
+     * @throws Exception
+     */
+    public function createAttributes(string $collection, array $attributes): bool
+    {
+        if (empty($attributes)) {
+            throw new DatabaseException('No attributes to create');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        $schemaAttributes = $this->adapter->hasFeature(Feature\SchemaAttributes::class)
+            ? $this->getSchemaAttributes($collection->getId())
+            : [];
+
+        $attributeModels = [];
+        $attributesToCreate = [];
+        foreach ($attributes as $attribute) {
+            if (empty($attribute->key)) {
+                throw new DatabaseException('Missing attribute key');
+            }
+
+            $existsInSchema = false;
+
+            try {
+                $attribute = $this->validateAttribute(
+                    $collection,
+                    $attribute->key,
+                    $attribute->type->value,
+                    $attribute->size,
+                    $attribute->required,
+                    $attribute->default,
+                    $attribute->signed,
+                    $attribute->array,
+                    $attribute->format,
+                    $attribute->formatOptions,
+                    $attribute->filters,
+                    $schemaAttributes
+                );
+            } catch (DuplicateException $e) {
+                // Check if the duplicate is in metadata or only in schema
+                $existsInMetadata = false;
+                /** @var array<Attribute> $checkAttrs2 */
+                $checkAttrs2 = $collection->getAttribute('attributes', []);
+                foreach ($checkAttrs2 as $attr) {
+                    if (\strtolower($attr->key) === \strtolower($attribute->key)) {
+                        $existsInMetadata = true;
+                        break;
+                    }
+                }
+
+                if ($existsInMetadata) {
+                    throw $e;
+                }
+
+                // Schema-only orphan — check type match
+                $expectedColumnType = $this->adapter->hasFeature(Feature\ColumnTypes::class)
+                    ? $this->adapter->getColumnType(
+                        $attribute->type->value,
+                        $attribute->size,
+                        $attribute->signed,
+                        $attribute->array,
+                        $attribute->required
+                    )
+                    : '';
+                if ($expectedColumnType !== '') {
+                    $filteredId = $this->adapter->filter($attribute->key);
+                    foreach ($schemaAttributes as $schemaAttr) {
+                        if (\strtolower($schemaAttr->getId()) === \strtolower($filteredId)) {
+                            $rawColType2 = $schemaAttr->getAttribute('columnType', '');
+                            $actualColumnType = \strtoupper(\is_string($rawColType2) ? $rawColType2 : '');
+                            if ($actualColumnType !== \strtoupper($expectedColumnType)) {
+                                // Type mismatch — drop orphaned column so it gets recreated
+                                $this->adapter->deleteAttribute($collection->getId(), $attribute->key);
+                            } else {
+                                $existsInSchema = true;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+            }
+
+            $attributeModels[] = $attribute;
+            if (! $existsInSchema) {
+                $attributesToCreate[] = $attribute;
+            }
+        }
+
+        $created = false;
+
+        if (! empty($attributesToCreate)) {
+            try {
+                $created = $this->adapter->createAttributes($collection->getId(), $attributesToCreate);
+
+                if (! $created) {
+                    throw new DatabaseException('Failed to create attributes');
+                }
+            } catch (DuplicateException) {
+                // Batch failed because at least one column already exists.
+                // Fallback to per-attribute creation so non-duplicates still land in schema.
+                foreach ($attributesToCreate as $attr) {
+                    try {
+                        $this->adapter->createAttribute(
+                            $collection->getId(),
+                            $attr
+                        );
+                        $created = true;
+                    } catch (DuplicateException) {
+                        // Column already exists in schema — skip
+                    }
+                }
+            }
+        }
+
+        foreach ($attributeModels as $attributeModel) {
+            $collection->setAttribute('attributes', $attributeModel, SetType::Append);
+        }
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->cleanupAttributes($collection->getId(), $attributeModels),
+            shouldRollback: $created,
+            operationDescription: 'attributes creation',
+            rollbackReturnsErrors: true
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
+
+        $this->triggerHooks(Event::DocumentPurge, new Document([
+            Document::ID => $collection->getId(),
+            Document::COLLECTION => self::METADATA,
+        ]));
+
+        $this->triggerHooks(Event::AttributesCreate, \array_map(
+            static fn (Attribute $attribute): Document => $attribute->toDocument()
+                ->setAttribute(Document::COLLECTION, $collection->getId()),
+            $attributeModels,
+        ));
+
+        return true;
+    }
+
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<Document>|null  $schemaAttributes  Pre-fetched schema attributes, or null to fetch internally
+     *
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws Exception
+     */
+    private function validateAttribute(
+        Document $collection,
+        string $id,
+        string $type,
+        int $size,
+        bool $required,
+        mixed $default,
+        bool $signed,
+        bool $array,
+        ?string $format,
+        array $formatOptions,
+        array $filters,
+        ?array $schemaAttributes = null
+    ): Attribute {
+        $type = Attribute::normalizeType($type)->value;
+        if ($type === ColumnType::BigInteger->value || $type === ColumnType::BigSerial->value) {
+            $size = 0;
+        }
+
+        $attribute = Attribute::fromArray([
+            Document::ID => $id,
+            'key' => $id,
+            'type' => $type,
+            'size' => $size,
+            'required' => $required,
+            'default' => $default,
+            'signed' => $signed,
+            'array' => $array,
+            'format' => $format,
+            'formatOptions' => $formatOptions,
+            'filters' => $filters,
+        ]);
+
+        $collectionClone = clone $collection;
+        $collectionClone->setAttribute('attributes', $attribute, SetType::Append);
+
+        /** @var array<Attribute> $existingAttributes */
+        $existingAttributes = $collection->getAttribute('attributes', []);
+
+        $resolvedSchemaAttributes = $schemaAttributes ?? ($this->adapter->hasFeature(Feature\SchemaAttributes::class)
+            ? $this->getSchemaAttributes($collection->getId())
+            : []);
+        $typedSchemaAttrs = [];
+        foreach ($resolvedSchemaAttributes as $schemaAttribute) {
+            $typedSchemaAttrs[] = Attribute::fromArray($schemaAttribute->getArrayCopy());
+        }
+
+        $validator = new AttributeValidator(
+            attributes: $existingAttributes,
+            schemaAttributes: $typedSchemaAttrs,
+            maxAttributes: $this->adapter->getLimitForAttributes(),
+            maxWidth: $this->adapter->getDocumentSizeLimit(),
+            maxStringLength: $this->adapter->getLimitForString(),
+            maxVarcharLength: $this->adapter->getMaxVarcharLength(),
+            maxIntLength: $this->adapter->getLimitForInt(),
+            maxBigIntLength: $this->adapter->getLimitForBigInt(),
+            supportForSchemaAttributes: $this->adapter->hasFeature(Feature\SchemaAttributes::class),
+            supportForVectors: $this->adapter->supports(Capability::Vectors),
+            supportForSpatialAttributes: $this->adapter->hasFeature(Feature\Spatial::class),
+            supportForObject: $this->adapter->supports(Capability::Objects),
+            supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt),
+            attributeCountCallback: fn (Document $attrDoc) => $this->adapter->getCountOfAttributes($collectionClone),
+            attributeWidthCallback: fn (Document $attrDoc) => $this->adapter->getAttributeWidth($collectionClone),
+            filterCallback: fn (string $filterId) => $this->adapter->filter($filterId),
+            isMigrating: $this->isMigrating(),
+            sharedTables: $this->getSharedTables(),
+        );
+
+        $validator->isValid($attribute);
+
+        return $attribute;
+    }
+
+    /**
+     * Get the list of required filters for each data type
+     *
+     * @param  string|null  $type  Type of the attribute
+     * @return array<string>
+     */
+    protected function getRequiredFilters(?string $type): array
+    {
+        return match ($type) {
+            ColumnType::Datetime->value => ['datetime'],
+            default => [],
+        };
+    }
+
+    /**
+     * Function to validate if the default value of an attribute matches its attribute type
+     *
+     * @param  string  $type  Type of the attribute
+     * @param  mixed  $default  Default value of the attribute
+     *
+     * @throws DatabaseException
+     */
+    protected function validateDefaultTypes(string $type, mixed $default, bool $signed = true): void
+    {
+        $type = Attribute::normalizeType($type);
+        $defaultType = \gettype($default);
+
+        if ($defaultType === 'NULL') {
+            // Disable null. No validation required
+            return;
+        }
+
+        if ($defaultType === 'array') {
+            // Spatial types require the array itself
+            if (! \in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon, ColumnType::Object], true)) {
+                /** @var array<mixed> $defaultArr */
+                $defaultArr = $default;
+                foreach ($defaultArr as $value) {
+                    $this->validateDefaultTypes($type->value, $value, $signed);
+                }
+            }
+
+            return;
+        }
+
+        $defaultStr = \is_scalar($default) ? (string) $default : '[non-scalar]';
+
+        switch ($type) {
+            case ColumnType::String:
+            case ColumnType::Varchar:
+            case ColumnType::Text:
+            case ColumnType::MediumText:
+            case ColumnType::LongText:
+                if ($defaultType !== 'string') {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type->value);
+                }
+                break;
+            case ColumnType::Integer:
+            case ColumnType::Boolean:
+                if ($type->value !== $defaultType) {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type->value);
+                }
+                break;
+            case ColumnType::BigInteger:
+            case ColumnType::BigSerial:
+                if (! (new BigInt($signed, $this->adapter->supports(Capability::UnsignedBigInt)))->isValid($default)) {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type->value);
+                }
+                break;
+            case ColumnType::Float:
+            case ColumnType::Double:
+                if ($defaultType !== 'double') {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type->value);
+                }
+                break;
+            case ColumnType::Datetime:
+            case ColumnType::Timestamp:
+                if ($defaultType !== ColumnType::String->value) {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type->value);
+                }
+                break;
+            case ColumnType::Vector:
+                // When validating individual vector components (from recursion), they should be numeric
+                if ($defaultType !== 'double' && $defaultType !== 'integer') {
+                    throw new DatabaseException('Vector components must be numeric values (float or integer)');
+                }
+                break;
+            default:
+                $supportedTypes = [
+                    ColumnType::String->value,
+                    ColumnType::Varchar->value,
+                    ColumnType::Text->value,
+                    ColumnType::MediumText->value,
+                    ColumnType::LongText->value,
+                    ColumnType::Integer->value,
+                    ColumnType::BigInteger->value,
+                    ColumnType::Float->value,
+                    ColumnType::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
+                ];
+                if ($this->adapter->supports(Capability::Vectors)) {
+                    $supportedTypes[] = ColumnType::Vector->value;
+                }
+                if ($this->adapter->hasFeature(Feature\Spatial::class)) {
+                    \array_push($supportedTypes, ...[ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value]);
+                }
+                throw new DatabaseException('Unknown attribute type: '.$type->value.'. Must be one of '.implode(', ', $supportedTypes));
+        }
+    }
+
+    /**
+     * Update attribute metadata. Utility method for update attribute methods.
+     *
+     * @param  callable(Attribute, Document, int|string): void  $updateCallback
+     *
+     * @throws ConflictException
+     * @throws DatabaseException
+     */
+    protected function updateAttributeMeta(string $collection, string $id, callable $updateCallback): Attribute
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->getId() === self::METADATA) {
+            throw new DatabaseException('Cannot update metadata attributes');
+        }
+
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        $index = \array_search($id, \array_map(fn (Attribute $attribute) => $attribute->key, $attributes), true);
+
+        if ($index === false) {
+            throw new NotFoundException('Attribute not found');
+        }
+
+        $attribute = $attributes[$index];
+
+        $updateCallback($attribute, $collection, $index);
+        $attributes[$index] = $attribute;
+
+        $collection->setAttribute('attributes', $attributes);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: null,
+            shouldRollback: false,
+            operationDescription: "attribute metadata update '{$id}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        $this->triggerHooks(
+            Event::AttributeUpdate,
+            $attribute->toDocument()->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return $attribute;
+    }
+
+    /**
+     * Update required status of attribute.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  bool  $required  Whether the attribute should be required
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttributeRequired(string $collection, string $id, bool $required): Document
+    {
+        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($required) {
+            $attribute->setAttribute('required', $required);
+        })->toDocument();
+    }
+
+    /**
+     * Update format of attribute.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  string  $format  Validation format of attribute
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttributeFormat(string $collection, string $id, string $format): Document
+    {
+        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($format) {
+            $rawType = $attribute->getAttribute('type');
+            if (! $rawType instanceof ColumnType && ! \is_string($rawType)) {
+                throw new DatabaseException('Unknown attribute type');
+            }
+            $attrType = Attribute::normalizeType($rawType);
+            if (! Structure::hasFormat($format, $attrType)) {
+                throw new DatabaseException('Format "'.$format.'" not available for attribute type "'.$attrType->value.'"');
+            }
+
+            $attribute->setAttribute('format', $format);
+        })->toDocument();
+    }
+
+    /**
+     * Update format options of attribute.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  array<string, mixed>  $formatOptions  Assoc array with custom options for format validation
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttributeFormatOptions(string $collection, string $id, array $formatOptions): Document
+    {
+        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($formatOptions) {
+            $attribute->setAttribute('formatOptions', $formatOptions);
+        })->toDocument();
+    }
+
+    /**
+     * Update filters of attribute.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  array<string>  $filters  Filter names to apply to the attribute
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttributeFilters(string $collection, string $id, array $filters): Document
+    {
+        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($filters) {
+            $attribute->setAttribute('filters', $filters);
+        })->toDocument();
+    }
+
+    /**
+     * Update default value of attribute.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  mixed  $default  The new default value
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttributeDefault(string $collection, string $id, mixed $default = null): Document
+    {
+        return $this->updateAttributeMeta($collection, $id, function ($attribute) use ($default) {
+            if ($attribute->getAttribute('required') === true) {
+                throw new DatabaseException('Cannot set a default value on a required attribute');
+            }
+
+            $rawAttrType = $attribute->getAttribute('type');
+            $this->validateDefaultTypes(
+                $rawAttrType instanceof ColumnType || \is_string($rawAttrType) ? Attribute::normalizeType($rawAttrType)->value : '',
+                $default,
+                (bool) $attribute->getAttribute('signed', true),
+            );
+
+            $attribute->setAttribute('default', $default);
+        })->toDocument();
+    }
+
+    /**
+     * Update Attribute. This method is for updating data that causes underlying structure to change. Check out other updateAttribute methods if you are looking for metadata adjustments.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  ColumnType|string|null  $type  New column type, or null to keep existing
+     * @param  int|null  $size  New utf8mb4 chars length, or null to keep existing
+     * @param  bool|null  $required  New required status, or null to keep existing
+     * @param  mixed  $default  New default value
+     * @param  bool|null  $signed  New signed status, or null to keep existing
+     * @param  bool|null  $array  New array status, or null to keep existing
+     * @param  string|null  $format  New validation format, or null to keep existing
+     * @param  array<string, mixed>|null  $formatOptions  New format options, or null to keep existing
+     * @param  array<string>|null  $filters  New filters, or null to keep existing
+     * @param  string|null  $newKey  New attribute key for renaming, or null to keep existing
+     * @return Document The updated attribute
+     *
+     * @throws Exception
+     */
+    public function updateAttribute(string $collection, string $id, ColumnType|string|null $type = null, ?int $size = null, ?bool $required = null, mixed $default = null, ?bool $signed = null, ?bool $array = null, ?string $format = null, ?array $formatOptions = null, ?array $filters = null, ?string $newKey = null): Document
+    {
+        $type = $type === null ? null : Attribute::normalizeType($type)->value;
+        $collectionDoc = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collectionDoc->getId() === self::METADATA) {
+            throw new DatabaseException('Cannot update metadata attributes');
+        }
+
+        /** @var array<Attribute> $attributes */
+        $attributes = $collectionDoc->getAttribute('attributes', []);
+        $attributeIndex = \array_search($id, \array_map(fn (Attribute $attribute) => $attribute->key, $attributes), true);
+
+        if ($attributeIndex === false) {
+            throw new NotFoundException('Attribute not found');
+        }
+
+        $attribute = $attributes[$attributeIndex];
+
+        $rawOriginalType = $attribute->getAttribute('type');
+        if (! $rawOriginalType instanceof ColumnType && ! \is_string($rawOriginalType)) {
+            throw new DatabaseException('Unknown attribute type');
+        }
+        $originalType = Attribute::normalizeType($rawOriginalType)->value;
+        /** @var int $originalSize */
+        $originalSize = $attribute->getAttribute('size');
+        $originalSigned = (bool) $attribute->getAttribute('signed');
+        $originalArray = (bool) $attribute->getAttribute('array');
+        $originalRequired = (bool) $attribute->getAttribute('required');
+        /** @var string $originalKey */
+        $originalKey = $attribute->getAttribute('key');
+
+        $originalIndexes = [];
+        /** @var array<Document> $collectionIndexes */
+        $collectionIndexes = $collectionDoc->getAttribute('indexes', []);
+        foreach ($collectionIndexes as $index) {
+            $originalIndexes[] = clone $index;
+        }
+
+        $altering = ! \is_null($type)
+            || ! \is_null($size)
+            || ! \is_null($signed)
+            || ! \is_null($array)
+            || ! \is_null($newKey);
+        if ($type === null) {
+            $rawType = $attribute->getAttribute('type');
+            if (! $rawType instanceof ColumnType && ! \is_string($rawType)) {
+                throw new DatabaseException('Unknown attribute type');
+            }
+            $type = Attribute::normalizeType($rawType)->value;
+        }
+        if ($size === null) {
+            /** @var int $size */
+            $size = $attribute->getAttribute('size');
+        }
+        $signed ??= (bool) $attribute->getAttribute('signed');
+        $required ??= (bool) $attribute->getAttribute('required');
+        $default ??= $attribute->getAttribute('default');
+        $array ??= (bool) $attribute->getAttribute('array');
+        if ($format === null) {
+            $rawFormat = $attribute->getAttribute('format');
+            $format = \is_string($rawFormat) ? $rawFormat : null;
+        }
+        if ($formatOptions === null) {
+            $rawFormatOptions = $attribute->getAttribute('formatOptions');
+            /** @var array<string, mixed>|null $formatOptions */
+            $formatOptions = \is_array($rawFormatOptions) ? $rawFormatOptions : null;
+        }
+        if ($filters === null) {
+            $rawFilters = $attribute->getAttribute('filters');
+            /** @var array<string>|null $filters */
+            $filters = \is_array($rawFilters) ? $rawFilters : null;
+        }
+
+        if ($type === ColumnType::BigInteger->value || $type === ColumnType::BigSerial->value) {
+            $size = 0;
+        }
+
+        if ($required === true && ! \is_null($default)) {
+            $default = null;
+        }
+
+        // we need to alter table attribute type to NOT NULL/NULL for change in required
+        if (! $this->adapter->supports(Capability::SpatialIndexNull) && in_array($type, [ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value])) {
+            $altering = true;
+        }
+
+        switch ($type) {
+            case ColumnType::String->value:
+                if (empty($size)) {
+                    throw new DatabaseException('Size length is required');
+                }
+
+                if ($size > $this->adapter->getLimitForString()) {
+                    throw new DatabaseException('Max size allowed for string is: '.number_format($this->adapter->getLimitForString()));
+                }
+                break;
+
+            case ColumnType::Varchar->value:
+                if (empty($size)) {
+                    throw new DatabaseException('Size length is required');
+                }
+
+                if ($size > $this->adapter->getMaxVarcharLength()) {
+                    throw new DatabaseException('Max size allowed for varchar is: '.number_format($this->adapter->getMaxVarcharLength()));
+                }
+                break;
+
+            case ColumnType::Text->value:
+            case ColumnType::MediumText->value:
+            case ColumnType::LongText->value:
+                // Text types don't require size validation as they have fixed max sizes
+                break;
+
+            case ColumnType::Integer->value:
+                $limit = ($signed) ? $this->adapter->getLimitForInt() / 2 : $this->adapter->getLimitForInt();
+                if ($size > $limit) {
+                    throw new DatabaseException('Max size allowed for int is: '.number_format($limit));
+                }
+                break;
+            case ColumnType::BigInteger->value:
+            case ColumnType::BigSerial->value:
+                break;
+            case ColumnType::Float->value:
+            case ColumnType::Double->value:
+            case ColumnType::Boolean->value:
+            case ColumnType::Datetime->value:
+                if (! empty($size)) {
+                    throw new DatabaseException('Size must be empty');
+                }
+                break;
+            case ColumnType::Object->value:
+                if (! $this->adapter->supports(Capability::Objects)) {
+                    throw new DatabaseException('Object attributes are not supported');
+                }
+                if (! empty($size)) {
+                    throw new DatabaseException('Size must be empty for object attributes');
+                }
+                if (! empty($array)) {
+                    throw new DatabaseException('Object attributes cannot be arrays');
+                }
+                break;
+            case ColumnType::Point->value:
+            case ColumnType::Linestring->value:
+            case ColumnType::Polygon->value:
+                if (! $this->adapter->hasFeature(Feature\Spatial::class)) {
+                    throw new DatabaseException('Spatial attributes are not supported');
+                }
+                if (! empty($size)) {
+                    throw new DatabaseException('Size must be empty for spatial attributes');
+                }
+                if (! empty($array)) {
+                    throw new DatabaseException('Spatial attributes cannot be arrays');
+                }
+                break;
+            case ColumnType::Vector->value:
+                if (! $this->adapter->supports(Capability::Vectors)) {
+                    throw new DatabaseException('Vector types are not supported by the current database');
+                }
+                if ($array) {
+                    throw new DatabaseException('Vector type cannot be an array');
+                }
+                if ($size <= 0) {
+                    throw new DatabaseException('Vector dimensions must be a positive integer');
+                }
+                if ($size > self::MAX_VECTOR_DIMENSIONS) {
+                    throw new DatabaseException('Vector dimensions cannot exceed '.self::MAX_VECTOR_DIMENSIONS);
+                }
+                if ($default !== null) {
+                    if (! \is_array($default)) {
+                        throw new DatabaseException('Vector default value must be an array');
+                    }
+                    if (\count($default) !== $size) {
+                        throw new DatabaseException('Vector default value must have exactly '.$size.' elements');
+                    }
+                    foreach ($default as $component) {
+                        if (! \is_int($component) && ! \is_float($component)) {
+                            throw new DatabaseException('Vector default value must contain only numeric elements');
+                        }
+                    }
+                }
+                break;
+            default:
+                $supportedTypes = [
+                    ColumnType::String->value,
+                    ColumnType::Varchar->value,
+                    ColumnType::Text->value,
+                    ColumnType::MediumText->value,
+                    ColumnType::LongText->value,
+                    ColumnType::Integer->value,
+                    ColumnType::BigInteger->value,
+                    ColumnType::Float->value,
+                    ColumnType::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
+                ];
+                if ($this->adapter->supports(Capability::Vectors)) {
+                    $supportedTypes[] = ColumnType::Vector->value;
+                }
+                if ($this->adapter->hasFeature(Feature\Spatial::class)) {
+                    \array_push($supportedTypes, ...[ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value]);
+                }
+                throw new DatabaseException('Unknown attribute type: '.$type.'. Must be one of '.implode(', ', $supportedTypes));
+        }
+
+        /** Ensure required filters for the attribute are passed */
+        $requiredFilters = $this->getRequiredFilters($type);
+        if (! empty(array_diff($requiredFilters, (array) $filters))) {
+            throw new DatabaseException("Attribute of type: $type requires the following filters: ".implode(',', $requiredFilters));
+        }
+
+        if ($format) {
+            if (! Structure::hasFormat($format, Attribute::normalizeType($type))) {
+                throw new DatabaseException('Format ("'.$format.'") not available for this attribute type ("'.$type.'")');
+            }
+        }
+
+        if (! \is_null($default)) {
+            if ($required) {
+                throw new DatabaseException('Cannot set a default value on a required attribute');
+            }
+
+            $this->validateDefaultTypes($type, $default, $signed);
+        }
+
+        $attribute
+            ->setAttribute(Document::ID, $newKey ?? $id)
+            ->setAttribute('key', $newKey ?? $id)
+            ->setAttribute('type', $type)
+            ->setAttribute('size', $size)
+            ->setAttribute('signed', $signed)
+            ->setAttribute('array', $array)
+            ->setAttribute('format', $format)
+            ->setAttribute('formatOptions', $formatOptions)
+            ->setAttribute('filters', $filters)
+            ->setAttribute('required', $required)
+            ->setAttribute('default', $default);
+
+        /** @var array<Attribute> $attributes */
+        $attributes = $collectionDoc->getAttribute('attributes', []);
+        $attributes[$attributeIndex] = $attribute;
+        $collectionDoc->setAttribute('attributes', $attributes, SetType::Assign);
+
+        if (
+            $this->adapter->getDocumentSizeLimit() > 0 &&
+            $this->adapter->getAttributeWidth($collectionDoc) >= $this->adapter->getDocumentSizeLimit()
+        ) {
+            throw new LimitException('Row width limit reached. Cannot update attribute.');
+        }
+
+        if (in_array($type, [ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value], true) && ! $this->adapter->supports(Capability::SpatialIndexNull)) {
+            /** @var array<string, Attribute> $typedAttributeMap */
+            $typedAttributeMap = [];
+            foreach ($attributes as $typedAttr) {
+                $typedAttributeMap[\strtolower($typedAttr->key)] = $typedAttr;
+            }
+
+            /** @var array<Index> $spatialIndexes */
+            $spatialIndexes = $collectionDoc->getAttribute('indexes', []);
+            foreach ($spatialIndexes as $typedIndex) {
+                if ($typedIndex->type !== IndexType::Spatial) {
+                    continue;
+                }
+                foreach ($typedIndex->attributes as $attributeName) {
+                    $lookup = \strtolower($attributeName);
+                    if (! isset($typedAttributeMap[$lookup])) {
+                        continue;
+                    }
+                    $typedAttr = $typedAttributeMap[$lookup];
+
+                    if (in_array($typedAttr->type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true) && ! $typedAttr->required) {
+                        throw new IndexException('Spatial indexes do not allow null values. Mark the attribute "'.$attributeName.'" as required or create the index on a column with no null values.');
+                    }
+                }
+            }
+        }
+
+        $updated = false;
+
+        if ($altering) {
+            /** @var array<Document> $indexes */
+            $indexes = $collectionDoc->getAttribute('indexes', []);
+
+            if (! \is_null($newKey) && $id !== $newKey) {
+                foreach ($indexes as $index) {
+                    /** @var array<string> $indexAttrList */
+                    $indexAttrList = (array) $index['attributes'];
+                    if (in_array($id, $indexAttrList)) {
+                        $index['attributes'] = array_map(fn ($attribute) => $attribute === $id ? $newKey : $attribute, $indexAttrList);
+                    }
+                }
+
+                /**
+                 * Check index dependency if we are changing the key
+                 */
+                /** @var array<Index> $depIndexes */
+                $depIndexes = $collectionDoc->getAttribute('indexes', []);
+                $validator = new IndexDependencyValidator(
+                    $depIndexes,
+                    $this->adapter->supports(Capability::CastIndexArray),
+                );
+
+                if (! $validator->isValid($attribute)) {
+                    throw new DependencyException($validator->getDescription());
+                }
+            }
+
+            /**
+             * Since we allow changing type & size we need to validate index length
+             */
+            if ($this->validate) {
+                $validator = new IndexValidator(
+                    $attributes,
+                    $originalIndexes,
+                    $this->adapter->getMaxIndexLength(),
+                    $this->adapter->getInternalIndexesKeys(),
+                    $this->adapter->supports(Capability::IndexArray),
+                    $this->adapter->supports(Capability::SpatialIndexNull),
+                    $this->adapter->supports(Capability::SpatialIndexOrder),
+                    $this->adapter->supports(Capability::Vectors),
+                    $this->adapter->supports(Capability::DefinedAttributes),
+                    $this->adapter->supports(Capability::MultipleFulltextIndexes),
+                    $this->adapter->supports(Capability::IdenticalIndexes),
+                    $this->adapter->supports(Capability::ObjectIndexes),
+                    $this->adapter->supports(Capability::TrigramIndex),
+                    $this->adapter->hasFeature(Feature\Spatial::class),
+                    $this->adapter->supports(Capability::Index),
+                    $this->adapter->supports(Capability::UniqueIndex),
+                    $this->adapter->supports(Capability::Fulltext),
+                    $this->adapter->supports(Capability::TTLIndexes),
+                    $this->adapter->supports(Capability::Objects)
+                );
+
+                foreach ($indexes as $index) {
+                    if (! $validator->isValid($index)) {
+                        throw new IndexException($validator->getDescription());
+                    }
+                }
+            }
+
+            $updateAttrModel = new Attribute(
+                key: $id,
+                type: Attribute::normalizeType($type),
+                size: $size,
+                required: $required,
+                default: $default,
+                signed: $signed,
+                array: $array,
+                format: $format,
+                formatOptions: $formatOptions ?? [],
+                filters: $filters ?? [],
+            );
+            $updated = $this->adapter->updateAttribute($collection, $updateAttrModel, $newKey);
+
+            if (! $updated) {
+                throw new DatabaseException('Failed to update attribute');
+            }
+        }
+
+        $collectionDoc->setAttribute('attributes', $attributes);
+
+        $rollbackAttrModel = new Attribute(
+            key: $newKey ?? $id,
+            type: Attribute::normalizeType($originalType),
+            size: $originalSize,
+            required: $originalRequired,
+            signed: $originalSigned,
+            array: $originalArray,
+        );
+        $this->updateMetadata(
+            collection: $collectionDoc,
+            rollbackOperation: fn () => $this->adapter->updateAttribute(
+                $collection,
+                $rollbackAttrModel,
+                $originalKey
+            ),
+            shouldRollback: $updated,
+            operationDescription: "attribute update '{$id}'",
+            silentRollback: true
+        );
+
+        if ($altering) {
+            $this->withRetries(fn () => $this->purgeCachedCollection($collection));
+        }
+        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection));
+
+        $this->triggerHooks(Event::DocumentPurge, new Document([
+            Document::ID => $collection,
+            Document::COLLECTION => self::METADATA,
+        ]));
+
+        $attributeDocument = $attribute->toDocument();
+
+        $this->triggerHooks(
+            Event::AttributeUpdate,
+            (clone $attributeDocument)->setAttribute(Document::COLLECTION, $collection),
+        );
+
+        return $attributeDocument;
+    }
+
+    /**
+     * Checks if attribute can be added to collection without exceeding limits.
+     *
+     * @param  Document  $collection  The collection document
+     * @param  Attribute  $attribute  The attribute to check
+     * @return bool True if the attribute can be added
+     *
+     * @throws LimitException
+     */
+    public function checkAttribute(Document $collection, Attribute $attribute): bool
+    {
+        $collection = clone $collection;
+
+        $collection->setAttribute('attributes', $attribute, SetType::Append);
+
+        if (
+            $this->adapter->getLimitForAttributes() > 0 &&
+            $this->adapter->getCountOfAttributes($collection) > $this->adapter->getLimitForAttributes()
+        ) {
+            throw new LimitException('Column limit reached. Cannot create new attribute. Current attribute count is '.$this->adapter->getCountOfAttributes($collection).' but the maximum is '.$this->adapter->getLimitForAttributes().'. Remove some attributes to free up space.');
+        }
+
+        if (
+            $this->adapter->getDocumentSizeLimit() > 0 &&
+            $this->adapter->getAttributeWidth($collection) >= $this->adapter->getDocumentSizeLimit()
+        ) {
+            throw new LimitException('Row width limit reached. Cannot create new attribute. Current row width is '.$this->adapter->getAttributeWidth($collection).' bytes but the maximum is '.$this->adapter->getDocumentSizeLimit().' bytes. Reduce the size of existing attributes or remove some attributes to free up space.');
+        }
+
+        return true;
+    }
+
+    /**
+     * Delete Attribute
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The attribute identifier to delete
+     * @return bool True if the attribute was deleted successfully
+     *
+     * @throws ConflictException
+     * @throws DatabaseException
+     */
+    public function deleteAttribute(string $collection, string $id): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Index> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        /** @var Attribute|null $attribute */
+        $attribute = null;
+
+        foreach ($attributes as $key => $value) {
+            if ($value->getId() === $id) {
+                $attribute = $value;
+                unset($attributes[$key]);
+                break;
+            }
+        }
+
+        if (\is_null($attribute)) {
+            throw new NotFoundException('Attribute not found');
+        }
+
+        if (Attribute::isRelationship($attribute)) {
+            throw new DatabaseException('Cannot delete relationship as an attribute');
+        }
+
+        if ($this->validate) {
+            /** @var array<Index> $depIndexes */
+            $depIndexes = $collection->getAttribute('indexes', []);
+            $validator = new IndexDependencyValidator(
+                $depIndexes,
+                $this->adapter->supports(Capability::CastIndexArray),
+            );
+
+            if (! $validator->isValid($attribute)) {
+                throw new DependencyException($validator->getDescription());
+            }
+        }
+
+        foreach ($indexes as $indexKey => $index) {
+            /** @var array<string> $indexAttributes */
+            $indexAttributes = $index->getAttribute('attributes', []);
+
+            $indexAttributes = \array_filter($indexAttributes, fn ($attr) => $attr !== $id);
+
+            if (empty($indexAttributes)) {
+                unset($indexes[$indexKey]);
+            } else {
+                $index->setAttribute('attributes', \array_values($indexAttributes));
+            }
+        }
+
+        $collection->setAttribute('attributes', \array_values($attributes));
+        $collection->setAttribute('indexes', \array_values($indexes));
+
+        $shouldRollback = false;
+        try {
+            if (! $this->adapter->deleteAttribute($collection->getId(), $id)) {
+                throw new DatabaseException('Failed to delete attribute');
+            }
+            $shouldRollback = true;
+        } catch (NotFoundException) {
+            // Ignore
+        }
+
+        $rawAttrTypeForRollback = $attribute->getAttribute('type');
+        $rawAttrSizeForRollback = $attribute->getAttribute('size');
+        /** @var string $rollbackAttrType */
+        $rollbackAttrType = \is_string($rawAttrTypeForRollback) ? $rawAttrTypeForRollback : '';
+        /** @var int $rollbackAttrSize */
+        $rollbackAttrSize = \is_int($rawAttrSizeForRollback) ? $rawAttrSizeForRollback : 0;
+        $rollbackAttr = new Attribute(
+            key: $id,
+            type: Attribute::normalizeType($rollbackAttrType),
+            size: $rollbackAttrSize,
+            required: (bool) ($attribute->getAttribute('required') ?? false),
+            signed: (bool) ($attribute->getAttribute('signed') ?? true),
+            array: (bool) ($attribute->getAttribute('array') ?? false),
+        );
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->adapter->createAttribute(
+                $collection->getId(),
+                $rollbackAttr
+            ),
+            shouldRollback: $shouldRollback,
+            operationDescription: "attribute deletion '{$id}'",
+            silentRollback: true
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+        $this->withRetries(fn () => $this->purgeCachedDocumentInternal(self::METADATA, $collection->getId()));
+
+        $this->triggerHooks(Event::DocumentPurge, new Document([
+            Document::ID => $collection->getId(),
+            Document::COLLECTION => self::METADATA,
+        ]));
+
+        $this->triggerHooks(
+            Event::AttributeDelete,
+            (clone $attribute)->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    /**
+     * Rename Attribute
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $old  Current attribute ID
+     * @param  string  $new  New attribute ID
+     * @return bool True if the attribute was renamed successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws StructureException
+     */
+    public function renameAttribute(string $collection, string $old, string $new): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        /** @var array<Index> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $attribute = null;
+
+        foreach ($attributes as $value) {
+            if ($value->getId() === $old) {
+                $attribute = $value;
+            }
+
+            if ($value->getId() === $new) {
+                throw new DuplicateException('Attribute name already used');
+            }
+        }
+
+        if ($attribute === null) {
+            throw new NotFoundException('Attribute not found');
+        }
+
+        if ($this->validate) {
+            /** @var array<Index> $renameDepIndexes */
+            $renameDepIndexes = $collection->getAttribute('indexes', []);
+            $validator = new IndexDependencyValidator(
+                $renameDepIndexes,
+                $this->adapter->supports(Capability::CastIndexArray),
+            );
+
+            if (! $validator->isValid($attribute)) {
+                throw new DependencyException($validator->getDescription());
+            }
+        }
+
+        $attribute->setAttribute(Document::ID, $new);
+        $attribute->setAttribute('key', $new);
+
+        foreach ($indexes as $index) {
+            /** @var array<string> $indexAttributes */
+            $indexAttributes = $index->getAttribute('attributes', []);
+
+            $indexAttributes = \array_map(fn ($attr) => ($attr === $old) ? $new : $attr, $indexAttributes);
+
+            $index->setAttribute('attributes', $indexAttributes);
+        }
+
+        $renamed = false;
+        try {
+            $renamed = $this->adapter->renameAttribute($collection->getId(), $old, $new);
+            if (! $renamed) {
+                throw new DatabaseException('Failed to rename attribute');
+            }
+        } catch (Throwable $e) {
+            // Check if the rename already happened in schema (orphan from prior
+            // partial failure where rename succeeded but metadata update failed).
+            // We verified $new doesn't exist in metadata (above), so if $new
+            // exists in schema, it must be from a prior rename.
+            if ($this->adapter->hasFeature(Feature\SchemaAttributes::class)) {
+                $schemaAttributes = $this->getSchemaAttributes($collection->getId());
+                $filteredNew = $this->adapter->filter($new);
+                $newExistsInSchema = false;
+                foreach ($schemaAttributes as $schemaAttr) {
+                    if (\strtolower($schemaAttr->getId()) === \strtolower($filteredNew)) {
+                        $newExistsInSchema = true;
+                        break;
+                    }
+                }
+                if ($newExistsInSchema) {
+                    $renamed = true;
+                } else {
+                    throw new DatabaseException("Failed to rename attribute '{$old}' to '{$new}': ".$e->getMessage(), previous: $e);
+                }
+            } else {
+                throw new DatabaseException("Failed to rename attribute '{$old}' to '{$new}': ".$e->getMessage(), previous: $e);
+            }
+        }
+
+        $collection->setAttribute('attributes', $attributes);
+        $collection->setAttribute('indexes', $indexes);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->adapter->renameAttribute($collection->getId(), $new, $old),
+            shouldRollback: $renamed,
+            operationDescription: "attribute rename '{$old}' to '{$new}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        $this->triggerHooks(
+            Event::AttributeUpdate,
+            (clone $attribute)->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return $renamed;
+    }
+
+    /**
+     * Cleanup (delete) a single attribute with retry logic
+     *
+     * @param  string  $collectionId  The collection ID
+     * @param  string  $attributeId  The attribute ID
+     * @param  int  $maxAttempts  Maximum retry attempts
+     *
+     * @throws DatabaseException If cleanup fails after all retries
+     */
+    private function cleanupAttribute(
+        string $collectionId,
+        string $attributeId,
+        int $maxAttempts = 3
+    ): void {
+        $this->cleanup(
+            fn () => $this->adapter->deleteAttribute($collectionId, $attributeId),
+            'attribute',
+            $attributeId,
+            $maxAttempts
+        );
+    }
+
+    /**
+     * Cleanup (delete) multiple attributes with retry logic
+     *
+     * @param  string  $collectionId  The collection ID
+     * @param  array<Attribute>  $attributes  The attributes to cleanup
+     * @param  int  $maxAttempts  Maximum retry attempts per attribute
+     * @return array<string> Array of error messages for failed cleanups (empty if all succeeded)
+     */
+    private function cleanupAttributes(
+        string $collectionId,
+        array $attributes,
+        int $maxAttempts = 3
+    ): array {
+        $errors = [];
+
+        foreach ($attributes as $attribute) {
+            try {
+                $this->cleanupAttribute($collectionId, $attribute->getId(), $maxAttempts);
+            } catch (DatabaseException $e) {
+                // Continue cleaning up other attributes even if one fails
+                $errors[] = $e->getMessage();
+            }
+        }
+
+        return $errors;
+    }
+
+    /**
+     * Rollback metadata state by removing specified attributes from collection
+     *
+     * @param  Document  $collection  The collection document
+     * @param  array<string>  $attributeIds  Attribute IDs to remove
+     */
+    private function rollbackAttributeMetadata(Document $collection, array $attributeIds): void
+    {
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        $filteredAttributes = \array_filter(
+            $attributes,
+            fn (Attribute $attr) => ! \in_array($attr->getId(), $attributeIds)
+        );
+        $collection->setAttribute('attributes', \array_values($filteredAttributes));
+    }
+}
diff --git a/src/Database/Traits/Collections.php b/src/Database/Traits/Collections.php
new file mode 100644
index 0000000000..caa55b73f4
--- /dev/null
+++ b/src/Database/Traits/Collections.php
@@ -0,0 +1,575 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Exception;
+use Throwable;
+use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Index as IndexException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Index as IndexValidator;
+use Utopia\Database\Validator\Permissions;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Provides CRUD operations for database collections including creation, listing, sizing, and deletion.
+ */
+trait Collections
+{
+    /**
+     * Create Collection
+     *
+     * @param  Collection  $collection  Collection to create
+     * @return Collection The created collection metadata document
+     *
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     */
+    public function createCollection(Collection $collection): Collection
+    {
+        $id = $collection->id;
+        $name = $collection->name !== '' ? $collection->name : $collection->id;
+        $attributes = $collection->attributes;
+        $indexes = $collection->indexes;
+        $permissions = $collection->permissions ?? [Permission::create(Role::any())];
+        $documentSecurity = $collection->documentSecurity;
+        $metadata = $collection->metadata;
+
+        foreach ($attributes as $attribute) {
+            if (in_array($attribute->type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon, ColumnType::Vector, ColumnType::Object], true)) {
+                $existingFilters = $attribute->filters;
+                $attribute->filters = array_values(
+                    array_unique(array_merge($existingFilters, [$attribute->type->value]))
+                );
+                $attribute->setAttribute('filters', $attribute->filters);
+            }
+        }
+
+        if ($this->validate) {
+            $validator = new Permissions();
+            if (! $validator->isValid($permissions)) {
+                throw new DatabaseException($validator->getDescription());
+            }
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($id));
+
+        if (! $collection->isEmpty() && $id !== self::METADATA) {
+            throw new DuplicateException('Collection '.$id.' already exists');
+        }
+
+        // Enforce single TTL index per collection
+        if ($this->validate && $this->adapter->supports(Capability::TTLIndexes)) {
+            $ttlIndexes = array_filter($indexes, fn (Index $idx) => $idx->type === IndexType::Ttl);
+            if (count($ttlIndexes) > 1) {
+                throw new IndexException('There can be only one TTL index in a collection');
+            }
+        }
+
+        /**
+         * Fix metadata index length & orders
+         */
+        foreach ($indexes as $key => $index) {
+            $lengths = $index->lengths;
+            $orders = $index->orders;
+
+            foreach ($index->attributes as $i => $attr) {
+                foreach ($attributes as $collectionAttribute) {
+                    if ($collectionAttribute->key === $attr) {
+                        /**
+                         * mysql does not save length in collection when length = attributes size
+                         */
+                        if ($collectionAttribute->type === ColumnType::String) {
+                            if (! empty($lengths[$i]) && $lengths[$i] === $collectionAttribute->size && $this->adapter->getMaxIndexLength() > 0) {
+                                $lengths[$i] = null;
+                            }
+                        }
+
+                        $isArray = $collectionAttribute->array;
+                        if ($isArray) {
+                            if ($this->adapter->getMaxIndexLength() > 0) {
+                                $lengths[$i] = self::MAX_ARRAY_INDEX_LENGTH;
+                            }
+                            $orders[$i] = null;
+                        }
+                        break;
+                    }
+                }
+            }
+
+            $index->lengths = $lengths;
+            $index->orders = $orders;
+            $indexes[$key] = $index;
+        }
+
+        $collection = new Document(\array_merge([
+            Document::ID => ID::custom($id),
+            Document::PERMISSIONS => $permissions,
+            'name' => $name,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => $documentSecurity,
+        ], $metadata));
+
+        if ($this->validate) {
+            $validator = new IndexValidator(
+                $attributes,
+                [],
+                $this->adapter->getMaxIndexLength(),
+                $this->adapter->getInternalIndexesKeys(),
+                $this->adapter->supports(Capability::IndexArray),
+                $this->adapter->supports(Capability::SpatialIndexNull),
+                $this->adapter->supports(Capability::SpatialIndexOrder),
+                $this->adapter->supports(Capability::Vectors),
+                $this->adapter->supports(Capability::DefinedAttributes),
+                $this->adapter->supports(Capability::MultipleFulltextIndexes),
+                $this->adapter->supports(Capability::IdenticalIndexes),
+                $this->adapter->supports(Capability::ObjectIndexes),
+                $this->adapter->supports(Capability::TrigramIndex),
+                $this->adapter->hasFeature(Feature\Spatial::class),
+                $this->adapter->supports(Capability::Index),
+                $this->adapter->supports(Capability::UniqueIndex),
+                $this->adapter->supports(Capability::Fulltext),
+                $this->adapter->supports(Capability::TTLIndexes),
+                $this->adapter->supports(Capability::Objects)
+            );
+            foreach ($indexes as $index) {
+                if (! $validator->isValid($index)) {
+                    throw new IndexException($validator->getDescription());
+                }
+            }
+        }
+
+        // Check index limits, if given
+        if ($indexes && $this->adapter->getCountOfIndexes($collection) > $this->adapter->getLimitForIndexes()) {
+            throw new LimitException('Index limit of '.$this->adapter->getLimitForIndexes().' exceeded. Cannot create collection.');
+        }
+
+        // Check attribute limits, if given
+        if ($attributes) {
+            if (
+                $this->adapter->getLimitForAttributes() > 0 &&
+                $this->adapter->getCountOfAttributes($collection) > $this->adapter->getLimitForAttributes()
+            ) {
+                throw new LimitException('Attribute limit of '.$this->adapter->getLimitForAttributes().' exceeded. Cannot create collection.');
+            }
+
+            if (
+                $this->adapter->getDocumentSizeLimit() > 0 &&
+                $this->adapter->getAttributeWidth($collection) > $this->adapter->getDocumentSizeLimit()
+            ) {
+                throw new LimitException('Document size limit of '.$this->adapter->getDocumentSizeLimit().' exceeded. Cannot create collection.');
+            }
+        }
+
+        if ($this->validate) {
+            $supportsSpatial = $this->adapter->hasFeature(Feature\Spatial::class);
+            foreach ($attributes as $attribute) {
+                if (
+                    \in_array($attribute->type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)
+                    && ! $supportsSpatial
+                ) {
+                    throw new DatabaseException('Spatial attributes are not supported');
+                }
+            }
+        }
+
+        $created = false;
+
+        try {
+            $this->adapter->createCollection($id, $attributes, $indexes);
+            $created = true;
+        } catch (DuplicateException $e) {
+            if ($id === self::METADATA
+                || ($this->adapter->getSharedTables()
+                    && $this->adapter->exists($this->adapter->getDatabase(), $id))) {
+                // The metadata table must never be dropped during reconciliation.
+                // In shared-tables mode the physical table is reused across
+                // tenants. A DuplicateException simply means the table already
+                // exists for another tenant — not an orphan.
+            } else {
+                // The table exists and this process did not create it. It may
+                // belong to a peer that has not committed metadata yet, or it
+                // may be an orphan. Dropping it destroyed live collections
+                // during concurrent boot; attaching this caller's metadata to
+                // an unknown physical schema can invent columns that are not
+                // there. Leave the table and report Duplicate. Claiming the
+                // metadata row first is #939.
+                try {
+                    $this->purgeCachedDocument(self::METADATA, $id);
+                } catch (Throwable $cacheError) {
+                    Console::warning('Warning: Failed to purge stale collection cache: '.$cacheError->getMessage());
+                }
+                throw new DuplicateException('Collection '.$id.' already exists', previous: $e);
+            }
+        }
+
+        if ($id === self::METADATA) {
+            return $this->hydrateCollectionModels(Collection::fromArray(self::collectionMeta()));
+        }
+
+        try {
+            $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+        } catch (DuplicateException $e) {
+            // A concurrent creator committed the metadata for this id first, so
+            // the physical table is the one its metadata describes. Rolling back
+            // here would drop a live collection out from under it.
+            try {
+                $this->purgeCachedDocument(self::METADATA, $id);
+            } catch (Throwable $cacheError) {
+                Console::warning('Warning: Failed to purge stale collection cache: '.$cacheError->getMessage());
+            }
+            throw new DuplicateException('Collection '.$id.' already exists', previous: $e);
+        } catch (Throwable $e) {
+            if ($created) {
+                try {
+                    $this->cleanupCollection($id);
+                } catch (Throwable $e) {
+                    Console::error("Failed to rollback collection '{$id}': ".$e->getMessage());
+                }
+            }
+            throw new DatabaseException("Failed to create collection metadata for '{$id}': ".$e->getMessage(), previous: $e);
+        }
+
+        $this->triggerHooks(Event::CollectionCreate, $createdCollection);
+
+        return $this->hydrateCollectionModels($createdCollection);
+    }
+
+    /**
+     * Update Collections Permissions.
+     *
+     * @param  string  $id  The collection identifier
+     * @param  array<string>  $permissions  New permission strings
+     * @param  bool  $documentSecurity  Whether to enable document-level security
+     * @return Document The updated collection metadata document
+     *
+     * @throws ConflictException
+     * @throws DatabaseException
+     */
+    public function updateCollection(string $id, array $permissions, bool $documentSecurity): Document
+    {
+        if ($this->validate) {
+            $validator = new Permissions();
+            if (! $validator->isValid($permissions)) {
+                throw new DatabaseException($validator->getDescription());
+            }
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($id));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if (
+            $this->adapter->getSharedTables()
+            && $collection->getTenant() !== $this->adapter->getTenant()
+        ) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        $collection
+            ->setAttribute(Document::PERMISSIONS, $permissions)
+            ->setAttribute('documentSecurity', $documentSecurity);
+
+        $collection = $this->skipValidation(fn () => $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection)));
+
+        $this->triggerHooks(Event::CollectionUpdate, $collection);
+
+        return $collection;
+    }
+
+    /**
+     * Get Collection
+     *
+     * @param  string  $id  The collection identifier
+     * @return Collection The collection metadata document, or an empty Collection if not found
+     *
+     * @throws DatabaseException
+     */
+    public function getCollection(string $id): Collection
+    {
+        $collection = $this->silent(fn () => $this->getDocument(self::METADATA, $id));
+
+        if (
+            $id !== self::METADATA
+            && $this->adapter->getSharedTables()
+            && $collection->getTenant() !== null
+            && $collection->getTenant() !== $this->adapter->getTenant()
+        ) {
+            return new Collection();
+        }
+
+        $collection = $this->hydrateCollectionModels($collection);
+
+        $this->trigger(Event::CollectionRead, $collection);
+
+        return $collection;
+    }
+
+    private function hydrateCollectionModels(Document $collection): Collection
+    {
+        if ($collection->isEmpty()) {
+            return $collection instanceof Collection ? $collection : new Collection();
+        }
+
+        if (! $collection instanceof Collection) {
+            $collection = Collection::fromArray($collection->getArrayCopy());
+        }
+
+        $attributes = $collection->getAttribute('attributes', []);
+        if (\is_array($attributes)) {
+            $hydrated = [];
+            $changed = false;
+            foreach ($attributes as $attr) {
+                if ($attr instanceof Attribute) {
+                    $hydrated[] = $attr;
+                    continue;
+                }
+                if (! \is_array($attr)) {
+                    throw new DatabaseException('Collection attributes must be Attribute models');
+                }
+                $changed = true;
+                $typed = [];
+                foreach ($attr as $name => $item) {
+                    if (\is_string($name)) {
+                        $typed[$name] = $item;
+                    }
+                }
+                $hydrated[] = Attribute::fromArray($typed);
+            }
+            if ($changed) {
+                $collection->setAttribute('attributes', $hydrated);
+            }
+        }
+
+        $indexes = $collection->getAttribute('indexes', []);
+        if (\is_array($indexes)) {
+            $hydrated = [];
+            $changed = false;
+            foreach ($indexes as $idx) {
+                if ($idx instanceof Index) {
+                    $hydrated[] = $idx;
+                    continue;
+                }
+                if (! \is_array($idx)) {
+                    throw new DatabaseException('Collection indexes must be Index models');
+                }
+                $changed = true;
+                $typed = [];
+                foreach ($idx as $name => $item) {
+                    if (\is_string($name)) {
+                        $typed[$name] = $item;
+                    }
+                }
+                $hydrated[] = Index::fromArray($typed);
+            }
+            if ($changed) {
+                $collection->setAttribute('indexes', $hydrated);
+            }
+        }
+
+        return $collection;
+    }
+
+    /**
+     * List Collections
+     *
+     * @param  int  $limit  Maximum number of collections to return
+     * @param  int  $offset  Number of collections to skip
+     * @return array<Collection>
+     *
+     * @throws Exception
+     */
+    public function listCollections(int $limit = 25, int $offset = 0): array
+    {
+        $result = $this->silent(fn () => $this->find(self::METADATA, [
+            Query::limit($limit),
+            Query::offset($offset),
+        ]));
+
+        foreach ($result as $i => $listed) {
+            $result[$i] = $this->hydrateCollectionModels($listed);
+        }
+
+        $this->trigger(Event::CollectionList, $result);
+
+        return $result;
+    }
+
+    /**
+     * Get Collection Size
+     *
+     * @param  string  $collection  The collection identifier
+     * @return int The number of documents in the collection
+     *
+     * @throws Exception
+     */
+    public function getSizeOfCollection(string $collection): int
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if ($this->adapter->getSharedTables() && $collection->getTenant() !== $this->adapter->getTenant()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        return $this->adapter->getSizeOfCollection($collection->getId());
+    }
+
+    /**
+     * Get Collection Size on disk
+     *
+     * @param  string  $collection  The collection identifier
+     * @return int The collection size in bytes on disk
+     *
+     * @throws DatabaseException
+     * @throws NotFoundException
+     */
+    public function getSizeOfCollectionOnDisk(string $collection): int
+    {
+        if ($this->adapter->getSharedTables() && empty($this->adapter->getTenant())) {
+            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if ($this->adapter->getSharedTables() && $collection->getTenant() !== $this->adapter->getTenant()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        return $this->adapter->getSizeOfCollectionOnDisk($collection->getId());
+    }
+
+    /**
+     * Analyze a collection updating its metadata on the database engine.
+     *
+     * @param  string  $collection  The collection identifier
+     * @return bool True if the analysis completed successfully
+     */
+    public function analyzeCollection(string $collection): bool
+    {
+        return $this->adapter->analyzeCollection($collection);
+    }
+
+    /**
+     * Delete Collection
+     *
+     * @param  string  $id  The collection identifier
+     * @return bool True if the collection was successfully deleted
+     *
+     * @throws DatabaseException
+     */
+    public function deleteCollection(string $id): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($id));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if ($this->adapter->getSharedTables() && $collection->getTenant() !== $this->adapter->getTenant()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        /** @var array<Attribute> $allAttributes */
+        $allAttributes = $collection->getAttribute('attributes', []);
+        $relationships = \array_filter(
+            $allAttributes,
+            fn (Attribute $attribute) => $attribute->type === ColumnType::Relationship
+        );
+
+        foreach ($relationships as $relationship) {
+            $this->deleteRelationship($collection->getId(), $relationship->key);
+        }
+
+        // Re-fetch collection to get current state after relationship deletions
+        $currentCollection = $this->silent(fn () => $this->getCollection($id));
+        /** @var array<Attribute> $currentAttributes */
+        $currentAttributes = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('attributes', []);
+        /** @var array<Index> $currentIndexes */
+        $currentIndexes = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('indexes', []);
+
+        $schemaDeleted = false;
+        try {
+            $this->adapter->deleteCollection($id);
+            $schemaDeleted = true;
+        } catch (NotFoundException) {
+            // Ignore — collection already absent from schema
+        }
+
+        if ($id === self::METADATA) {
+            $deleted = true;
+        } else {
+            try {
+                $deleted = $this->silent(fn () => $this->deleteDocument(self::METADATA, $id));
+            } catch (Throwable $e) {
+                if ($schemaDeleted) {
+                    try {
+                        $this->adapter->createCollection($id, $currentAttributes, $currentIndexes);
+                    } catch (Throwable) {
+                        // Silent rollback — best effort to restore consistency
+                    }
+                }
+                throw new DatabaseException(
+                    "Failed to persist metadata for collection deletion '{$id}': ".$e->getMessage(),
+                    previous: $e
+                );
+            }
+        }
+
+        if ($deleted) {
+            $this->triggerHooks(Event::CollectionDelete, $collection);
+        }
+
+        $this->purgeCachedCollection($id);
+
+        return $deleted;
+    }
+
+    /**
+     * Cleanup (delete) a collection with retry logic
+     *
+     * @param  string  $collectionId  The collection ID
+     * @param  int  $maxAttempts  Maximum retry attempts
+     *
+     * @throws DatabaseException If cleanup fails after all retries
+     */
+    private function cleanupCollection(
+        string $collectionId,
+        int $maxAttempts = 3
+    ): void {
+        $this->cleanup(
+            fn () => $this->adapter->deleteCollection($collectionId),
+            'collection',
+            $collectionId,
+            $maxAttempts
+        );
+    }
+}
diff --git a/src/Database/Traits/Databases.php b/src/Database/Traits/Databases.php
new file mode 100644
index 0000000000..c51fcafb5a
--- /dev/null
+++ b/src/Database/Traits/Databases.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+
+/**
+ * Provides database-level operations including creation, existence checks, listing, and deletion.
+ */
+trait Databases
+{
+    /**
+     * Create Database
+     *
+     * @param  string|null  $database  Database name, defaults to the adapter's configured database
+     * @return bool True if the database was created successfully
+     */
+    public function create(?string $database = null): bool
+    {
+        $database ??= $this->adapter->getDatabase();
+
+        $this->adapter->create($database);
+
+        /** @var array<Attribute> $attributes */
+        $attributes = self::collectionMeta()['attributes'];
+
+        $this->silent(fn () => $this->createCollection(new Collection(
+            id: self::METADATA,
+            attributes: $attributes,
+        )));
+
+        $this->trigger(Event::DatabaseCreate, $database);
+
+        return true;
+    }
+
+    /**
+     * Check if database exists, and optionally check if a collection exists in the database.
+     *
+     * @param  string|null  $database  Database name, defaults to the adapter's configured database
+     * @param  string|null  $collection  Collection name to check for within the database
+     * @return bool True if the database (and optionally the collection) exists
+     */
+    public function exists(?string $database = null, ?string $collection = null): bool
+    {
+        $database ??= $this->adapter->getDatabase();
+
+        return $this->adapter->exists($database, $collection);
+    }
+
+    /**
+     * List Databases
+     *
+     * @return array<Document>
+     */
+    public function list(): array
+    {
+        $databases = $this->adapter->list();
+
+        $this->trigger(Event::DatabaseList, $databases);
+
+        return $databases;
+    }
+
+    /**
+     * Delete Database
+     *
+     * @param  string|null  $database  Database name, defaults to the adapter's configured database
+     * @return bool True if the database was deleted successfully
+     *
+     * @throws DatabaseException
+     */
+    public function delete(?string $database = null): bool
+    {
+        $database = $database ?? $this->adapter->getDatabase();
+
+        $deleted = $this->adapter->delete($database);
+
+        $this->trigger(Event::DatabaseDelete, [
+            'name' => $database,
+            'deleted' => $deleted,
+        ]);
+
+        $this->cache->flush();
+
+        return $deleted;
+    }
+}
diff --git a/src/Database/Traits/Documents.php b/src/Database/Traits/Documents.php
new file mode 100644
index 0000000000..daf26eb792
--- /dev/null
+++ b/src/Database/Traits/Documents.php
@@ -0,0 +1,3550 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use DateTime as PhpDateTime;
+use Exception;
+use Generator;
+use InvalidArgumentException;
+use Throwable;
+use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Change;
+use Utopia\Database\Database;
+use Utopia\Database\DateTime;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Order as OrderException;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Exception\Relationship as RelationshipException;
+use Utopia\Database\Exception\Restricted as RestrictedException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Exception\Timeout as TimeoutException;
+use Utopia\Database\Exception\Type as TypeException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index as IndexModel;
+use Utopia\Database\Operator;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\Validator\Authorization\Input;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Database\Validator\PartialStructure;
+use Utopia\Database\Validator\Permissions;
+use Utopia\Database\Validator\Queries\Document as DocumentValidator;
+use Utopia\Database\Validator\Queries\Documents as DocumentsValidator;
+use Utopia\Database\Validator\Structure;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Provides document CRUD operations including find, create, update, upsert, delete, and cache management.
+ */
+trait Documents
+{
+    private function getNumericResult(Attribute $attribute, mixed $current, int|float|string $value, bool $increase): int|float|string
+    {
+        if (Attribute::isIntegerType($attribute->type)) {
+            if (! $attribute->signed
+                && \in_array($attribute->type, [ColumnType::BigInteger, ColumnType::BigSerial], true)
+                && ! $this->adapter->supports(Capability::UnsignedBigInt)) {
+                throw new TypeException('Unsigned 64-bit arithmetic is not supported by this adapter.');
+            }
+            if ((! \is_int($current) && ! \is_string($current)) || ! BigInt::isIntegerString((string) $current)) {
+                throw new TypeException('Attribute value must be an integer.');
+            }
+            if ((! \is_int($value) && ! \is_string($value)) || ! BigInt::isIntegerString((string) $value)) {
+                throw new TypeException('Change value must be an integer.');
+            }
+
+            $result = $increase
+                ? BigInt::add($current, $value)
+                : BigInt::subtract($current, $value);
+            $bounds = Attribute::getNumericBounds($attribute->type, $attribute->signed);
+            if ($bounds === null) {
+                throw new TypeException('Attribute value must be numeric.');
+            }
+            if (BigInt::compare($result, $bounds['max']) > 0) {
+                throw new LimitException('Attribute value exceeds maximum limit: '.$bounds['max']);
+            }
+            if (BigInt::compare($result, $bounds['min']) < 0) {
+                throw new LimitException('Attribute value exceeds minimum limit: '.$bounds['min']);
+            }
+
+            return $result;
+        }
+
+        if (! \is_numeric($current)) {
+            throw new TypeException('Attribute value must be numeric.');
+        }
+
+        $current = $this->getNativeNumber($current);
+        $value = $this->getNativeNumber($value);
+        $bounds = Attribute::getNumericBounds($attribute->type, $attribute->signed);
+
+        if ($bounds === null || (\is_float($current) && ! \is_finite($current))) {
+            throw new TypeException('Attribute value must be a finite numeric value.');
+        }
+        $maximum = $this->getNativeNumber($bounds['max']);
+        $minimum = $this->getNativeNumber($bounds['min']);
+
+        if ($current > $maximum) {
+            throw new LimitException('Attribute value exceeds maximum limit: '.$maximum);
+        }
+
+        if ($current < $minimum) {
+            throw new LimitException('Attribute value exceeds minimum limit: '.$minimum);
+        }
+
+        $overflows = $increase
+            ? ($value > 0 && $current > $maximum - $value)
+            : ($value < 0 && $current > $maximum + $value);
+        if ($overflows) {
+            throw new LimitException('Attribute value exceeds maximum limit: '.$maximum);
+        }
+
+        $underflows = $increase
+            ? ($value < 0 && $current < $minimum - $value)
+            : ($value > 0 && $current < $minimum + $value);
+        if ($underflows) {
+            throw new LimitException('Attribute value exceeds minimum limit: '.$minimum);
+        }
+
+        $result = $increase ? $current + $value : $current - $value;
+        if (\is_float($result) && ! \is_finite($result)) {
+            throw new TypeException('Attribute value must be a finite numeric value.');
+        }
+
+        return $result;
+    }
+
+    private function getNativeNumber(int|float|string $value): int|float
+    {
+        if (\is_int($value) || \is_float($value)) {
+            return $value;
+        }
+        if (! \is_numeric($value)) {
+            throw new TypeException('Value must be numeric.');
+        }
+
+        return \str_contains(\strtolower($value), '.') || \str_contains(\strtolower($value), 'e')
+            ? (float) $value
+            : (int) $value;
+    }
+
+    /**
+     * Cached validator instances keyed by context and a
+     * stable schema/authorization fingerprint.
+     *
+     * Building DocumentsValidator deep-copies every collection attribute via
+     * Attribute::getArrayCopy(), which is expensive on the find/count/sum
+     * hot path. The composite key keeps the cache coherent when the same
+     * Database instance is reused across namespaces, tenants, or with a
+     * different max-query-values cap. Fresh collection metadata contributes
+     * a stable schema and authorization fingerprint to each key.
+     *
+     * @var array<string, DocumentsValidator>
+     */
+    private array $documentsValidatorCache = [];
+
+    private const int DOCUMENTS_VALIDATOR_CACHE_LIMIT = 256;
+
+    /**
+     * Return a DocumentsValidator for the given collection, building it on
+     * first request and caching the instance for subsequent calls. The cache
+     * is purged when the collection's schema changes.
+     */
+    protected function getDocumentsValidator(Document $collection): DocumentsValidator
+    {
+        $context = $this->getCollectionMetadataCacheKey($collection->getId());
+        $key = $this->documentsValidatorCacheKey($collection, $context);
+
+        if (isset($this->documentsValidatorCache[$key])) {
+            return $this->documentsValidatorCache[$key];
+        }
+
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $validator = new DocumentsValidator(
+            $attributes,
+            $indexes,
+            $this->adapter->getIdAttributeType(),
+            $this->maxQueryValues,
+            $this->adapter->getMaxUIDLength(),
+            $this->adapter->getMinDateTime(),
+            $this->adapter->getMaxDateTime(),
+            $this->adapter->supports(Capability::DefinedAttributes),
+            $this->adapter->supports(Capability::UnsignedBigInt)
+        );
+
+        if (\count($this->documentsValidatorCache) >= self::DOCUMENTS_VALIDATOR_CACHE_LIMIT) {
+            $this->documentsValidatorCache = [];
+        }
+        $this->documentsValidatorCache[$key] = $validator;
+
+        return $validator;
+    }
+
+    /**
+     * Build the composite cache key for the DocumentsValidator cache. Scoping
+     * by namespace + tenant + max-query-values keeps two collections that
+     * share an id (different tenant schemas, different namespace prefixes,
+     * or different per-request limits) from aliasing onto the same validator.
+     */
+    private function documentsValidatorCacheKey(Document $collection, string $context): string
+    {
+        $fingerprint = \hash('sha256', \serialize([
+            'attributes' => $this->normalizeQueryCacheQueryValue($collection->getAttribute('attributes', [])),
+            'indexes' => $this->normalizeQueryCacheQueryValue($collection->getAttribute('indexes', [])),
+            'permissions' => $this->normalizeQueryCacheQueryValue($collection->getAttribute(Document::PERMISSIONS, [])),
+            'documentSecurity' => (bool) $collection->getAttribute('documentSecurity', false),
+        ]));
+
+        return $context.'::'.$this->maxQueryValues.'::'.$fingerprint;
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $selections
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     */
+    protected function refetchDocuments(Document $collection, array $documents, array $selections = []): array
+    {
+        if (empty($documents)) {
+            return $documents;
+        }
+
+        $sequences = \array_map(function (Document $document): string {
+            $sequence = $document->getSequence();
+            if ($sequence === null) {
+                throw new DatabaseException('Cannot refetch document without a $sequence: '.$document->getId());
+            }
+
+            return $sequence;
+        }, $documents);
+
+        $refetchedMap = [];
+        foreach (\array_chunk($sequences, \max(1, $this->maxQueryValues)) as $chunk) {
+            $refetched = $this->getAuthorization()->skip(fn () => $this->silent(
+                fn () => $this->find(
+                    $collection->getId(),
+                    \array_merge([
+                        Query::equal(Document::SEQUENCE, $chunk),
+                        Query::limit(\count($chunk)),
+                    ], $selections)
+                )
+            ));
+
+            foreach ($refetched as $document) {
+                $sequence = $document->getSequence();
+                if ($sequence === null) {
+                    throw new DatabaseException('Cannot index refetched document without a $sequence: '.$document->getId());
+                }
+
+                $refetchedMap[$sequence] = $document;
+            }
+        }
+
+        $result = [];
+        foreach ($documents as $index => $document) {
+            $result[$index] = $refetchedMap[$sequences[$index]] ?? $document;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get Document
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The document identifier
+     * @param  array<Query>  $queries  Optional select/filter queries
+     * @param  bool  $forUpdate  Whether to lock the document for update
+     * @return Document The document, or an empty Document if not found
+     *
+     * @throws DatabaseException
+     * @throws QueryException
+     */
+    public function getDocument(string $collection, string $id, array $queries = [], bool $forUpdate = false): Document
+    {
+        if ($collection === self::METADATA && $id === self::METADATA) {
+            return new Document(self::collectionMeta());
+        }
+
+        if (empty($collection)) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        if (empty($id)) {
+            return new Document();
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = new DocumentValidator($attributes, $this->adapter->supports(Capability::DefinedAttributes));
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        /** @var array<Document> $allAttributes */
+        $allAttributes = $collection->getAttribute('attributes', []);
+        $relationships = \array_filter(
+            $allAttributes,
+            fn (Attribute|Document $attribute) => Attribute::isRelationship($attribute)
+        );
+
+        $grouped = Query::groupForDatabase($queries);
+        $selects = $grouped['selections'];
+        $joins = $grouped['joins'];
+
+        if (! empty($joins) && ! $this->adapter->supports(Capability::Joins)) {
+            throw new QueryException('Join queries are not supported by this adapter');
+        }
+
+        $joinDocumentSecurity = [];
+        if (! empty($joins)) {
+            $joinDocumentSecurity = $this->authorizeJoins($joins, PermissionType::Read);
+        }
+
+        $selections = $this->validateSelections($collection, $selects);
+        $nestedSelections = $this->relationshipHook?->processQueries($relationships, $queries) ?? [];
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+        [$collectionKey, , $hashKey] = $this->getCacheKeys(
+            $collection->getId(),
+            $id,
+            $selections
+        );
+
+        $cacheable = ! $forUpdate
+            && ! $this->adapter->inTransaction()
+            && $collection->getId() !== self::METADATA
+            && empty($joins);
+        $physicalKey = '';
+        if ($cacheable) {
+            $epoch = $this->getDocumentCacheEpoch($collectionKey);
+            if ($epoch === null) {
+                $cacheable = false;
+            } else {
+                $physicalKey = $hashKey.'#'.$epoch;
+            }
+        }
+        $cached = null;
+        if ($cacheable) {
+            try {
+                $cached = $this->cache->load($physicalKey, self::TTL);
+            } catch (Exception $e) {
+                Console::warning('Warning: Failed to get document from cache: '.$e->getMessage());
+            }
+        }
+
+        if (\is_array($cached) && isset($cached[self::CACHE_EMPTY_MARKER])) {
+            return $this->createDocumentInstance($collection->getId(), []);
+        }
+
+        if ($cached) {
+            /** @var array<string, mixed> $cached */
+            $document = $this->createDocumentInstance($collection->getId(), $cached);
+            $document = $this->casting($collection, $document);
+
+            if ($collection->getId() !== self::METADATA) {
+
+                if (! $this->authorization->isValid(new Input(PermissionType::Read, [
+                    ...$collection->getRead(),
+                    ...($documentSecurity ? $document->getRead() : []),
+                ]))) {
+                    return $this->createDocumentInstance($collection->getId(), []);
+                }
+            }
+
+            $document = $this->decorateDocument(Event::DocumentRead, $collection, $document);
+
+            $this->trigger(Event::DocumentRead, $document);
+
+            if ($this->isTtlExpired($collection, $document)) {
+                return $this->createDocumentInstance($collection->getId(), []);
+            }
+
+            return $document;
+        }
+
+        $generation = '0';
+        if ($cacheable) {
+            try {
+                $generation = $this->cache->getGeneration($physicalKey);
+            } catch (Exception $e) {
+                Console::warning('Warning: Failed to get cache generation: '.$e->getMessage());
+            }
+        }
+
+        $skipAuth = empty($joins)
+            && $collection->getId() !== self::METADATA
+            && $this->authorization->isValid(new Input(PermissionType::Read, $collection->getRead()));
+
+        $getDocument = fn () => $this->adapter->getDocument(
+            $this->withJoinDocumentSecurity($collection, $joinDocumentSecurity),
+            $id,
+            $queries,
+            $forUpdate
+        );
+
+        $document = $skipAuth ? $this->authorization->skip($getDocument) : $getDocument();
+
+        if ($document->isEmpty()) {
+            $missing = true;
+            if ($cacheable && empty($relationships) && $documentSecurity && ! $skipAuth) {
+                $missing = $this->authorization->skip($getDocument)->isEmpty();
+            }
+
+            if ($cacheable && empty($relationships) && $missing) {
+                try {
+                    $marker = [self::CACHE_EMPTY_MARKER => true];
+                    $this->cache->saveWithLease($physicalKey, $marker, '', $generation);
+                } catch (Exception $e) {
+                    Console::warning('Failed to save empty document to cache: '.$e->getMessage());
+                }
+            }
+
+            return $this->createDocumentInstance($collection->getId(), []);
+        }
+
+        if ($this->isTtlExpired($collection, $document)) {
+            return $this->createDocumentInstance($collection->getId(), []);
+        }
+
+        $document = $this->castingAfter($collection, $document);
+
+        // Convert to custom document type if mapped
+        if (isset($this->documentTypes[$collection->getId()])) {
+            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
+        }
+
+        $document->setAttribute(Document::COLLECTION, $collection->getId());
+
+        if ($collection->getId() !== self::METADATA) {
+            if (! $this->authorization->isValid(new Input(PermissionType::Read, [
+                ...$collection->getRead(),
+                ...($documentSecurity ? $document->getRead() : []),
+            ]))) {
+                return $this->createDocumentInstance($collection->getId(), []);
+            }
+        }
+
+        $document = $this->casting($collection, $document);
+        $document = $this->decode($collection, $document, $selections);
+
+        // Skip relationship population if we're in batch mode (relationships will be populated later)
+        if ($this->relationshipHook !== null && ! $this->relationshipHook->isInBatchPopulation() && $this->relationshipHook->isEnabled() && ! empty($relationships) && (empty($selects) || ! empty($nestedSelections))) {
+            $documents = $this->silent(fn () => $this->relationshipHook->populateDocuments([$document], $collection, $this->relationshipHook->getFetchDepth(), $nestedSelections));
+            $document = $documents[0];
+        }
+
+        /** @var array<Document> $cacheCheckAttrs */
+        $cacheCheckAttrs = $collection->getAttribute('attributes', []);
+        $relationships = \array_filter(
+            $cacheCheckAttrs,
+            fn (Attribute|Document $attribute) => Attribute::isRelationship($attribute)
+        );
+
+        // Locking reads happen inside a transaction and must never cache the
+        // pre-commit row. Register the key only after the leased save succeeds.
+        if ($cacheable && empty($relationships)) {
+            try {
+                $this->cache->saveWithLease($physicalKey, $document->getArrayCopy(), '', $generation);
+            } catch (Exception $e) {
+                Console::warning('Failed to save document to cache: '.$e->getMessage());
+            }
+        }
+
+        $document = $this->decorateDocument(Event::DocumentRead, $collection, $document);
+
+        $this->trigger(Event::DocumentRead, $document);
+
+        return $document;
+    }
+
+    private function isTtlExpired(Document $collection, Document $document): bool
+    {
+        if (! $this->adapter->supports(Capability::TTLIndexes)) {
+            return false;
+        }
+        /** @var array<IndexModel> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+        foreach ($indexes as $index) {
+            if ($index->type !== IndexType::Ttl) {
+                continue;
+            }
+            $ttlSeconds = $index->ttl;
+            $ttlAttr = $index->attributes[0] ?? null;
+            if ($ttlSeconds <= 0 || ! $ttlAttr) {
+                return false;
+            }
+            /** @var string $ttlAttrStr */
+            $ttlAttrStr = $ttlAttr;
+            $val = $document->getAttribute($ttlAttrStr);
+            if (is_string($val)) {
+                try {
+                    $start = new PhpDateTime($val);
+
+                    return (new PhpDateTime()) > (clone $start)->modify("+{$ttlSeconds} seconds");
+                } catch (Throwable) {
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Strip non-selected attributes from documents based on select queries.
+     *
+     * @param  array<Document>  $documents
+     * @param  array<Query>  $selectQueries
+     */
+    public function applySelectFiltersToDocuments(array $documents, array $selectQueries): void
+    {
+        if (empty($selectQueries) || empty($documents)) {
+            return;
+        }
+
+        // Collect all attributes to keep from select queries
+        $attributesToKeep = [];
+        foreach ($selectQueries as $selectQuery) {
+            foreach ($selectQuery->getValues() as $value) {
+                /** @var string $strValue */
+                $strValue = $value;
+                $attributesToKeep[$strValue] = true;
+            }
+        }
+
+        // Early return if wildcard selector present
+        if (isset($attributesToKeep['*'])) {
+            return;
+        }
+
+        // Always preserve internal attributes (use hashmap for O(1) lookup)
+        $internalKeys = \array_map(fn (array $attr) => $attr[Document::ID] ?? '', $this->getInternalAttributes());
+        foreach ($internalKeys as $key) {
+            /** @var string $key */
+            $attributesToKeep[$key] = true;
+        }
+
+        foreach ($documents as $doc) {
+            $allKeys = \array_keys($doc->getArrayCopy());
+            foreach ($allKeys as $attrKey) {
+                // Keep if: explicitly selected OR is internal attribute ($ prefix)
+                if (! isset($attributesToKeep[$attrKey]) && ! \str_starts_with($attrKey, '$')) {
+                    $doc->removeAttribute($attrKey);
+                }
+            }
+        }
+    }
+
+    /**
+     * Create Document
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  Document  $document  The document to create
+     * @return Document The created document with generated ID and timestamps
+     *
+     * @throws AuthorizationException
+     * @throws DatabaseException
+     * @throws StructureException
+     */
+    public function createDocument(string $collection, Document $document): Document
+    {
+        if (
+            $collection !== self::METADATA
+            && $this->adapter->getSharedTables()
+            && ! $this->adapter->getTenantPerDocument()
+            && empty($this->adapter->getTenant())
+        ) {
+            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
+        }
+
+        if (
+            ! $this->adapter->getSharedTables()
+            && $this->adapter->getTenantPerDocument()
+        ) {
+            throw new DatabaseException('Shared tables must be enabled if tenant per document is enabled.');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->getId() !== self::METADATA) {
+            $isValid = $this->authorization->isValid(new Input(PermissionType::Create, $collection->getCreate()));
+            if (! $isValid) {
+                throw new AuthorizationException($this->authorization->getDescription());
+            }
+        }
+
+        $time = DateTime::now();
+
+        $createdAt = $document->getCreatedAt();
+        $updatedAt = $document->getUpdatedAt();
+
+        $id = $document->getId();
+        $document
+            ->setAttribute(Document::ID, (empty($id) || $id === 'unique()') ? ID::unique() : $id)
+            ->setAttribute(Document::COLLECTION, $collection->getId())
+            ->setAttribute(Document::CREATED_AT, ($createdAt === null || ! $this->preserveDates) ? $time : $createdAt)
+            ->setAttribute(Document::UPDATED_AT, ($updatedAt === null || ! $this->preserveDates) ? $time : $updatedAt);
+
+        if ($collection->getId() !== self::METADATA) {
+            $document->setAttribute(Document::VERSION, 1);
+        }
+
+        if (empty($document->getPermissions())) {
+            $document->setAttribute(Document::PERMISSIONS, []);
+        }
+
+        if ($this->adapter->getSharedTables()) {
+            if ($this->adapter->getTenantPerDocument()) {
+                if (
+                    $collection->getId() !== static::METADATA
+                    && $document->getTenant() === null
+                ) {
+                    throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
+                }
+            } else {
+                $document->setAttribute(Document::TENANT, $this->adapter->getTenant());
+            }
+        }
+
+        $document = $this->encode($collection, $document);
+
+        if ($this->validate) {
+            $validator = new Permissions();
+            if (! $validator->isValid($document->getPermissions())) {
+                throw new DatabaseException($validator->getDescription());
+            }
+        }
+
+        if ($this->validate) {
+            $structure = new Structure(
+                collection: $collection,
+                idAttributeType: $this->adapter->getIdAttributeType(),
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime(),
+                supportForAttributes: $this->adapter->supports(Capability::DefinedAttributes),
+                supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt)
+            );
+            if (! $structure->isValid($document)) {
+                throw new StructureException($structure->getDescription());
+            }
+        }
+
+        $document = $this->castingBefore($collection, $document);
+
+        $cacheTarget = $collection->getId() === self::METADATA ? $document : $collection->getId();
+        $document = $this->withMutation(Event::DocumentCreate, $cacheTarget, function () use ($collection, $document) {
+            $hook = $this->relationshipHook;
+            if ($hook?->isEnabled()) {
+                $document = $this->silent(fn () => $hook->afterDocumentCreate($collection, $document));
+            }
+
+            $document = $this->adapter->createDocument($collection, $document);
+            $this->withDocumentTenant(
+                $document,
+                fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId())
+            );
+
+            return $document;
+        });
+
+        $hook = $this->relationshipHook;
+        if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+            $fetchDepth = $hook->getWriteStackCount();
+            $documents = $this->silent(fn () => $hook->populateDocuments([$document], $collection, $fetchDepth));
+            $document = $documents[0];
+        }
+
+        $document = $this->castingAfter($collection, $document);
+        $document = $this->casting($collection, $document);
+        $document = $this->decode($collection, $document);
+
+        // Convert to custom document type if mapped
+        if (isset($this->documentTypes[$collection->getId()])) {
+            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
+        }
+
+        $document = $this->decorateDocument(Event::DocumentCreate, $collection, $document);
+
+        $this->triggerHooks(Event::DocumentCreate, $document);
+
+        return $document;
+    }
+
+    /**
+     * Create Documents in a batch
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Document>  $documents  The documents to create
+     * @param  int  $batchSize  Number of documents per batch insert
+     * @param  (callable(Document): void)|null  $onNext  Callback invoked for each created document
+     * @param  (callable(Throwable): void)|null  $onError  Callback invoked on per-document errors
+     * @return int The number of documents created
+     *
+     * @throws AuthorizationException
+     * @throws StructureException
+     * @throws Throwable
+     * @throws Exception
+     */
+    public function createDocuments(
+        string $collection,
+        array $documents,
+        int $batchSize = self::INSERT_BATCH_SIZE,
+        ?callable $onNext = null,
+        ?callable $onError = null,
+    ): int {
+        if (
+            $this->adapter->getSharedTables()
+            && ! $this->adapter->getTenantPerDocument()
+            && empty($this->adapter->getTenant())
+        ) {
+            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
+        }
+
+        if (! $this->adapter->getSharedTables() && $this->adapter->getTenantPerDocument()) {
+            throw new DatabaseException('Shared tables must be enabled if tenant per document is enabled.');
+        }
+
+        if (empty($documents)) {
+            return 0;
+        }
+
+        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        if ($collection->getId() !== self::METADATA) {
+            if (! $this->authorization->isValid(new Input(PermissionType::Create, $collection->getCreate()))) {
+                throw new AuthorizationException($this->authorization->getDescription());
+            }
+        }
+
+        $time = DateTime::now();
+        $modified = 0;
+
+        // Hoisted: validator only depends on the collection + adapter properties,
+        // both stable for this call. Allocating once and reusing across all
+        // documents avoids per-document construction and (with the in-class
+        // memo) per-document `array_merge` of the attribute list.
+        $validator = $this->validate
+            ? new Structure(
+                collection: $collection,
+                idAttributeType: $this->adapter->getIdAttributeType(),
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime(),
+                supportForAttributes: $this->adapter->supports(Capability::DefinedAttributes),
+                supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt)
+            )
+            : null;
+
+        foreach ($documents as $document) {
+            $createdAt = $document->getCreatedAt();
+            $updatedAt = $document->getUpdatedAt();
+
+            $document
+                ->setAttribute(Document::ID, (empty($document->getId()) || $document->getId() === 'unique()') ? ID::unique() : $document->getId())
+                ->setAttribute(Document::COLLECTION, $collection->getId())
+                ->setAttribute(Document::CREATED_AT, ($createdAt === null || ! $this->preserveDates) ? $time : $createdAt)
+                ->setAttribute(Document::UPDATED_AT, ($updatedAt === null || ! $this->preserveDates) ? $time : $updatedAt);
+
+            if ($collection->getId() !== self::METADATA) {
+                $document->setAttribute(Document::VERSION, 1);
+            }
+
+            if (empty($document->getPermissions())) {
+                $document->setAttribute(Document::PERMISSIONS, []);
+            }
+
+            if ($this->adapter->getSharedTables()) {
+                if ($this->adapter->getTenantPerDocument()) {
+                    if ($document->getTenant() === null) {
+                        throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
+                    }
+                } else {
+                    $document->setAttribute(Document::TENANT, $this->adapter->getTenant());
+                }
+            }
+
+            $document = $this->encode($collection, $document);
+
+            if ($validator !== null) {
+                if (! $validator->isValid($document)) {
+                    throw new StructureException($validator->getDescription());
+                }
+            }
+
+            if ($this->relationshipHook?->isEnabled()) {
+                $document = $this->silent(fn () => $this->relationshipHook->afterDocumentCreate($collection, $document));
+            }
+
+            $document = $this->castingBefore($collection, $document);
+        }
+
+        foreach (\array_chunk($documents, $batchSize) as $chunk) {
+            $cacheTarget = $collection->getId() === self::METADATA ? $chunk : $collection->getId();
+            $insert = fn () => $this->withMutation(
+                Event::DocumentsCreate,
+                $cacheTarget,
+                function () use ($collection, $chunk): array {
+                    $batch = $this->adapter->createDocuments($collection, $chunk);
+
+                    foreach ($batch as $document) {
+                        $this->withDocumentTenant(
+                            $document,
+                            fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId())
+                        );
+                    }
+
+                    return $batch;
+                }
+            );
+            $batch = $this->skipDuplicates
+                ? $this->adapter->skipDuplicates($insert)
+                : $insert();
+
+            $batch = $this->adapter->getSequences($collection->getId(), $batch);
+
+            $hook = $this->relationshipHook;
+            if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+                $batch = $this->silent(fn () => $hook->populateDocuments($batch, $collection, $hook->getFetchDepth()));
+            }
+
+            /** @var array<Document> $batch */
+            $batch = \array_map(
+                fn (Document $document) =>
+                $this->decode(
+                    $collection,
+                    $this->casting(
+                        $collection,
+                        $this->castingAfter($collection, $document)
+                    )
+                ),
+                $batch
+            );
+
+            $batch = $this->decorateDocuments(Event::DocumentsCreate, $collection, $batch);
+
+            foreach ($batch as $document) {
+                try {
+                    $onNext && $onNext($document);
+                } catch (Throwable $e) {
+                    $onError ? $onError($e) : throw $e;
+                }
+
+                $modified++;
+            }
+        }
+
+        $this->triggerHooks(Event::DocumentsCreate, new Document([
+            Document::COLLECTION => $collection->getId(),
+            'modified' => $modified,
+        ]));
+
+        return $modified;
+    }
+
+    /**
+     * Update Document
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The document identifier
+     * @param  Document  $document  The document with updated fields
+     * @return Document The updated document
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws StructureException
+     */
+    public function updateDocument(string $collection, string $id, Document $document): Document
+    {
+        if (! $id) {
+            throw new DatabaseException('Must define $id attribute');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        $newUpdatedAt = $document->getUpdatedAt();
+        $hasOperators = false;
+        $cacheTarget = $collection->getId() === self::METADATA
+            ? new Document([Document::ID => $id, Document::COLLECTION => self::METADATA])
+            : $collection->getId();
+        $document = $this->withMutation(Event::DocumentUpdate, $cacheTarget, function () use ($collection, $id, $document, $newUpdatedAt, &$hasOperators) {
+            $old = $this->authorization->skip(fn () => $this->silent(
+                fn () => $this->getDocument($collection->getId(), $id, forUpdate: true)
+            ));
+            if ($old->isEmpty()) {
+                return new Document();
+            }
+            $time = DateTime::nowAfter($old->getUpdatedAt() ?: null);
+
+            $skipPermissionsUpdate = true;
+
+            if ($document->offsetExists(Document::PERMISSIONS)) {
+                $originalPermissions = $old->getPermissions();
+                $currentPermissions = $document->getPermissions();
+
+                sort($originalPermissions);
+                sort($currentPermissions);
+
+                $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
+            }
+            $createdAt = $document->getCreatedAt();
+
+            $document = \array_merge($old->getArrayCopy(), $document->getArrayCopy());
+            $document[Document::COLLECTION] = $old->getAttribute(Document::COLLECTION); // Make sure user doesn't switch collection ID
+            $incomingId = $document[Document::ID] ?? '';
+            if (\is_string($incomingId) && \strcasecmp($incomingId, $old->getId()) === 0) {
+                $document[Document::ID] = $old->getId();
+            }
+            $document[Document::CREATED_AT] = ($createdAt === null || ! $this->preserveDates) ? $old->getCreatedAt() : $createdAt;
+
+            if ($this->adapter->getSharedTables()) {
+                $document[Document::TENANT] = $old->getTenant(); // Make sure user doesn't switch tenant
+            }
+            $document = new Document($document);
+
+            // Ahead of change detection: a dropped attribute is never persisted, so
+            // counting it as a change would bump $updatedAt and fire an update event
+            // for a write that leaves the stored document identical.
+            $document = $this->removeUnknownAttributes($collection, $document);
+
+            /** @var array<Document> $updateAttrs */
+            $updateAttrs = $collection->getAttribute('attributes', []);
+            $relationships = \array_filter($updateAttrs, function (Attribute|Document $attribute) {
+                return Attribute::isRelationship($attribute);
+            });
+
+            $shouldUpdate = false;
+
+            if ($collection->getId() !== self::METADATA) {
+                $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+                foreach ($relationships as $relationship) {
+                    $relationships[$relationship->getId()] = $relationship;
+                }
+
+                foreach ($document as $key => $value) {
+                    if (Operator::isOperator($value)) {
+                        $shouldUpdate = true;
+                        break;
+                    }
+                }
+
+                $internalKeys = [Document::INTERNAL_ID, Document::COLLECTION, Document::TENANT, Document::SEQUENCE];
+
+                // Compare if the document has any changes
+                foreach ($document as $key => $value) {
+                    if (\in_array($key, $internalKeys, true)) {
+                        continue;
+                    }
+
+                    if (\array_key_exists($key, $relationships)) {
+                        if ($this->relationshipHook !== null && $this->relationshipHook->getWriteStackCount() >= Database::RELATION_MAX_DEPTH - 1) {
+                            continue;
+                        }
+
+                        $rel = Relationship::fromArray(['collection' => $collection->getId()] + $relationships[$key]->getArrayCopy());
+                        $relationType = $rel->type;
+                        $side = $rel->side;
+                        switch ($relationType) {
+                            case RelationType::OneToOne:
+                                $oldValue = $old->getAttribute($key) instanceof Document
+                                    ? $old->getAttribute($key)->getId()
+                                    : $old->getAttribute($key);
+
+                                if ((\is_null($value) !== \is_null($oldValue))
+                                    || (\is_string($value) && $value !== $oldValue)
+                                    || ($value instanceof Document && $value->getId() !== $oldValue)
+                                ) {
+                                    $shouldUpdate = true;
+                                }
+                                break;
+                            case RelationType::OneToMany:
+                            case RelationType::ManyToOne:
+                            case RelationType::ManyToMany:
+                                if (
+                                    ($relationType === RelationType::ManyToOne && $side === RelationSide::Parent) ||
+                                    ($relationType === RelationType::OneToMany && $side === RelationSide::Child)
+                                ) {
+                                    $oldValue = $old->getAttribute($key) instanceof Document
+                                        ? $old->getAttribute($key)->getId()
+                                        : $old->getAttribute($key);
+
+                                    if ((\is_null($value) !== \is_null($oldValue))
+                                        || (\is_string($value) && $value !== $oldValue)
+                                        || ($value instanceof Document && $value->getId() !== $oldValue)
+                                    ) {
+                                        $shouldUpdate = true;
+                                    }
+                                    break;
+                                }
+
+                                if (Operator::isOperator($value)) {
+                                    $shouldUpdate = true;
+                                    break;
+                                }
+
+                                if (! \is_array($value) || ! \array_is_list($value)) {
+                                    throw new RelationshipException('Invalid relationship value. Must be either an array of documents or document IDs, '.\gettype($value).' given.');
+                                }
+
+                                /** @var array<mixed> $oldRelValues */
+                                $oldRelValues = $old->getAttribute($key);
+                                if (\count($oldRelValues) !== \count($value)) {
+                                    $shouldUpdate = true;
+                                    break;
+                                }
+
+                                foreach ($value as $index => $relation) {
+                                    $oldValue = $oldRelValues[$index] instanceof Document
+                                        ? $oldRelValues[$index]->getId()
+                                        : $oldRelValues[$index];
+
+                                    if (
+                                        (\is_string($relation) && $relation !== $oldValue) ||
+                                        ($relation instanceof Document && $relation->getId() !== $oldValue)
+                                    ) {
+                                        $shouldUpdate = true;
+                                        break;
+                                    }
+                                }
+                                break;
+                        }
+
+                        if ($shouldUpdate) {
+                            break;
+                        }
+
+                        continue;
+                    }
+
+                    $oldValue = $old->getAttribute($key);
+
+                    // If values are not equal we need to update document.
+                    if (! self::valuesEqual($value, $oldValue)) {
+                        $shouldUpdate = true;
+                        break;
+                    }
+                }
+
+                $updatePermissions = [
+                    ...$collection->getUpdate(),
+                    ...($documentSecurity ? $old->getUpdate() : []),
+                ];
+
+                $readPermissions = [
+                    ...$collection->getRead(),
+                    ...($documentSecurity ? $old->getRead() : []),
+                ];
+
+                if ($shouldUpdate) {
+                    if (! $this->authorization->isValid(new Input(PermissionType::Update, $updatePermissions))) {
+                        throw new AuthorizationException($this->authorization->getDescription());
+                    }
+                } else {
+                    if (! $this->authorization->isValid(new Input(PermissionType::Read, $readPermissions))) {
+                        throw new AuthorizationException($this->authorization->getDescription());
+                    }
+                }
+            }
+
+            if ($shouldUpdate) {
+                $document->setAttribute(Document::UPDATED_AT, ($newUpdatedAt === null || ! $this->preserveDates) ? $time : $newUpdatedAt);
+            }
+
+            // Check if document was updated after the request timestamp
+            $oldUpdatedAt = new PhpDateTime($old->getUpdatedAt() ?? 'now');
+            if (! is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
+                throw new ConflictException('Document was updated after the request timestamp');
+            }
+
+            $oldVersion = $old->getVersion();
+            if ($oldVersion !== null && $shouldUpdate) {
+                $document->setAttribute(Document::VERSION, $oldVersion + 1);
+            } elseif ($oldVersion !== null) {
+                $document->setAttribute(Document::VERSION, $oldVersion);
+            }
+
+            $document = $this->encode($collection, $document);
+
+            if ($this->validate) {
+                $structureValidator = new Structure(
+                    collection: $collection,
+                    idAttributeType: $this->adapter->getIdAttributeType(),
+                    minAllowedDate: $this->adapter->getMinDateTime(),
+                    maxAllowedDate: $this->adapter->getMaxDateTime(),
+                    supportForAttributes: $this->adapter->supports(Capability::DefinedAttributes),
+                    supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt),
+                    currentDocument: $old
+                );
+                if (! $structureValidator->isValid($document)) { // Make sure updated structure still apply collection rules (if any)
+                    throw new StructureException($structureValidator->getDescription());
+                }
+            }
+
+            if ($this->relationshipHook?->isEnabled()) {
+                $document = $this->silent(fn () => $this->relationshipHook->afterDocumentUpdate($collection, $old, $document));
+            }
+
+            foreach ($document->getArrayCopy() as $value) {
+                if (Operator::isOperator($value)) {
+                    $hasOperators = true;
+                    break;
+                }
+            }
+
+            $document = $this->castingBefore($collection, $document);
+
+            $this->authorization->skip(fn () => $this->adapter->updateDocument($collection, $id, $document, $skipPermissionsUpdate));
+
+            $document = $this->castingAfter($collection, $document);
+
+            $this->purgeCachedDocumentInternal($collection->getId(), $id);
+
+            if ($document->getId() !== $id) {
+                $this->purgeCachedDocumentInternal($collection->getId(), $document->getId());
+            }
+
+            if ($hasOperators) {
+                $refetched = $this->refetchDocuments($collection, [$document]);
+                $document = $refetched[0];
+            }
+
+            return $document;
+        });
+
+        if ($document->isEmpty()) {
+            return $document;
+        }
+
+        $this->purgeCachedDocumentInternal($collection->getId(), $id);
+
+        $hook = $this->relationshipHook;
+        if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+            $documents = $this->silent(fn () => $hook->populateDocuments([$document], $collection, $hook->getFetchDepth()));
+            $document = $documents[0];
+        }
+
+        if (! $hasOperators) {
+            $document = $this->decode($collection, $document);
+        }
+
+        // Convert to custom document type if mapped
+        if (isset($this->documentTypes[$collection->getId()])) {
+            $document = $this->createDocumentInstance($collection->getId(), $document->getArrayCopy());
+        }
+
+        $document = $this->decorateDocument(Event::DocumentUpdate, $collection, $document);
+
+        $this->triggerHooks(Event::DocumentUpdate, $document);
+
+        return $document;
+    }
+
+    /**
+     * Update documents
+     *
+     * Updates all documents which match the given queries.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  Document  $updates  The document containing fields to update
+     * @param  array<Query>  $queries  Queries to filter documents for update
+     * @param  int  $batchSize  Number of documents per batch update
+     * @param  (callable(Document $updated, Document $old): void)|null  $onNext  Callback invoked for each updated document
+     * @param  (callable(Throwable): void)|null  $onError  Callback invoked on per-document errors
+     * @return int The number of documents updated
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DuplicateException
+     * @throws QueryException
+     * @throws StructureException
+     * @throws TimeoutException
+     * @throws Throwable
+     * @throws Exception
+     */
+    public function updateDocuments(
+        string $collection,
+        Document $updates,
+        array $queries = [],
+        int $batchSize = self::INSERT_BATCH_SIZE,
+        ?callable $onNext = null,
+        ?callable $onError = null,
+    ): int {
+        if ($updates->isEmpty()) {
+            return 0;
+        }
+
+        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        if ($collection->isEmpty()) {
+            throw new DatabaseException('Collection not found');
+        }
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        $skipAuth = $this->authorization->isValid(new Input(PermissionType::Update, $collection->getUpdate()));
+
+        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+            throw new AuthorizationException($this->authorization->getDescription());
+        }
+
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = $this->getDocumentsValidator($collection);
+
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        $grouped = Query::groupForDatabase($queries);
+        $limit = $grouped['limit'];
+        $cursor = $grouped['cursor'];
+
+        if (! empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
+            throw new DatabaseException('Cursor document must be from the same Collection.');
+        }
+
+        unset($updates[Document::ID]);
+        unset($updates[Document::TENANT]);
+
+        if (($updates->getCreatedAt() === null || ! $this->preserveDates)) {
+            unset($updates[Document::CREATED_AT]);
+        } else {
+            $updates[Document::CREATED_AT] = $updates->getCreatedAt();
+        }
+
+        if ($this->adapter->getSharedTables()) {
+            $updates[Document::TENANT] = $this->adapter->getTenant();
+        }
+
+        $updatedAt = $updates->getUpdatedAt();
+        $updates[Document::UPDATED_AT] = ($updatedAt === null || ! $this->preserveDates) ? DateTime::now() : $updatedAt;
+
+        $updates = $this->encode(
+            $collection,
+            $updates,
+            applyDefaults: false
+        );
+
+        if ($this->validate) {
+            $validator = new PartialStructure(
+                collection: $collection,
+                idAttributeType: $this->adapter->getIdAttributeType(),
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime(),
+                supportForAttributes: $this->adapter->supports(Capability::DefinedAttributes),
+                supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt),
+                currentDocument: null
+            );
+
+            if (! $validator->isValid($updates)) {
+                throw new StructureException($validator->getDescription());
+            }
+        }
+
+        $hasOperators = false;
+        $adapterData = [];
+        foreach ($updates->getArrayCopy() as $key => $value) {
+            if ($value instanceof Operator) {
+                $hasOperators = true;
+                $value = clone $value;
+            }
+            $adapterData[$key] = $value;
+        }
+        $selections = $this->validateSelections($collection, $grouped['selections']);
+        $adapterUpdates = $this->castingBefore($collection, new Document($adapterData));
+
+        $originalLimit = $limit;
+        $last = $cursor;
+        $modified = 0;
+
+        while (true) {
+            if ($limit && $limit < $batchSize) {
+                $batchSize = $limit;
+            } elseif (! empty($limit)) {
+                $limit -= $batchSize;
+            }
+
+            $new = [
+                Query::limit($batchSize),
+            ];
+
+            if (! empty($last)) {
+                $new[] = Query::cursorAfter($last);
+            }
+
+            $batch = $this->silent(fn () => $this->find(
+                $collection->getId(),
+                array_merge($new, $queries),
+                forPermission: PermissionType::Update
+            ));
+
+            if (empty($batch)) {
+                break;
+            }
+
+            $old = array_map(fn ($doc) => clone $doc, $batch);
+            $currentPermissions = $updates->getPermissions();
+            sort($currentPermissions);
+
+            $cacheTarget = $collection->getId() === self::METADATA ? $batch : $collection->getId();
+            $this->withMutation(Event::DocumentsUpdate, $cacheTarget, function () use ($collection, $updates, $adapterUpdates, &$batch, $currentPermissions) {
+                foreach ($batch as $index => $document) {
+                    $skipPermissionsUpdate = true;
+
+                    if ($updates->offsetExists(Document::PERMISSIONS)) {
+                        if (! $document->offsetExists(Document::PERMISSIONS)) {
+                            throw new QueryException('Permission document missing in select');
+                        }
+
+                        $originalPermissions = $document->getPermissions();
+
+                        \sort($originalPermissions);
+
+                        $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
+                    }
+
+                    $document->setAttribute(Document::SKIP_PERMISSIONS_UPDATE, $skipPermissionsUpdate);
+
+                    $updateData = [];
+                    foreach ($updates->getArrayCopy() as $key => $value) {
+                        $updateData[$key] = $value instanceof Operator ? clone $value : $value;
+                    }
+                    $new = new Document(\array_merge($document->getArrayCopy(), $updateData));
+
+                    $hook = $this->relationshipHook;
+                    if ($hook?->isEnabled()) {
+                        $this->silent(fn () => $hook->afterDocumentUpdate($collection, $document, $new));
+                    }
+
+                    $document = $new;
+
+                    // Check if document was updated after the request timestamp
+                    try {
+                        $oldUpdatedAt = new PhpDateTime($document->getUpdatedAt() ?? 'now');
+                    } catch (Exception $e) {
+                        throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+                    }
+
+                    if (! is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
+                        throw new ConflictException('Document was updated after the request timestamp');
+                    }
+
+                    $docVersion = $document->getVersion();
+                    if ($docVersion !== null) {
+                        $document->setAttribute(Document::VERSION, $docVersion + 1);
+                    }
+
+                    $encoded = $this->encode($collection, $document);
+                    $batch[$index] = $this->castingBefore($collection, $encoded);
+                }
+
+                $this->adapter->updateDocuments(
+                    $collection,
+                    $adapterUpdates,
+                    $batch
+                );
+
+                foreach ($batch as $document) {
+                    $this->withDocumentTenant(
+                        $document,
+                        fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId())
+                    );
+                }
+            });
+
+            if ($hasOperators) {
+                $batch = $this->refetchDocuments($collection, $batch, $grouped['selections']);
+            }
+
+            /** @var array<Document> $batch */
+            $batch = \array_map(
+                fn (Document $doc) =>
+                $this->decode(
+                    $collection,
+                    $this->castingAfter($collection, $doc),
+                    $selections
+                ),
+                $batch
+            );
+
+            $batch = $this->decorateDocuments(Event::DocumentsUpdate, $collection, $batch);
+
+            foreach ($batch as $index => $doc) {
+                $doc->removeAttribute(Document::SKIP_PERMISSIONS_UPDATE);
+                try {
+                    $onNext && $onNext($doc, $old[$index]);
+                } catch (Throwable $th) {
+                    $onError ? $onError($th) : throw $th;
+                }
+                $modified++;
+            }
+
+            if (count($batch) < $batchSize) {
+                break;
+            } elseif ($originalLimit && $modified == $originalLimit) {
+                break;
+            }
+
+            /** @var Document|false $last */
+            $last = \end($batch);
+        }
+
+        $this->triggerHooks(Event::DocumentsUpdate, new Document([
+            Document::COLLECTION => $collection->getId(),
+            'modified' => $modified,
+        ]));
+
+        return $modified;
+    }
+
+    /**
+     * Create or update a single document.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  Document  $document  The document to create or update
+     * @return Document The created or updated document
+     *
+     * @throws StructureException
+     * @throws Throwable
+     */
+    public function upsertDocument(
+        string $collection,
+        Document $document,
+    ): Document {
+        $result = null;
+
+        $this->upsertDocumentsWithIncrease(
+            $collection,
+            '',
+            [$document],
+            function (Document $doc, ?Document $_old = null) use (&$result) {
+                $result = $doc;
+            }
+        );
+
+        if ($result === null) {
+            // No-op (unchanged): return the current persisted doc
+            $result = $this->getDocument($collection, $document->getId());
+        }
+
+        return $result;
+    }
+
+    /**
+     * Create or update documents.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Document>  $documents  The documents to create or update
+     * @param  int  $batchSize  Number of documents per batch
+     * @param  (callable(Document, ?Document): void)|null  $onNext  Callback invoked for each upserted document with optional old document
+     * @param  (callable(Throwable): void)|null  $onError  Callback invoked on per-document errors
+     * @return int The number of documents created or updated
+     *
+     * @throws StructureException
+     * @throws Throwable
+     */
+    public function upsertDocuments(
+        string $collection,
+        array $documents,
+        int $batchSize = self::INSERT_BATCH_SIZE,
+        ?callable $onNext = null,
+        ?callable $onError = null
+    ): int {
+        return $this->upsertDocumentsWithIncrease(
+            $collection,
+            '',
+            $documents,
+            $onNext,
+            $onError,
+            $batchSize
+        );
+    }
+
+    /**
+     * Create or update documents, increasing the value of the given attribute by the value in each document.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $attribute  The attribute to increment on update
+     * @param  array<Document>  $documents  The documents to create or update
+     * @param  (callable(Document, ?Document): void)|null  $onNext  Callback invoked for each upserted document with optional old document
+     * @param  (callable(Throwable): void)|null  $onError  Callback invoked on per-document errors
+     * @param  int  $batchSize  Number of documents per batch
+     * @return int The number of documents created or updated
+     *
+     * @throws StructureException
+     * @throws Throwable
+     * @throws Exception
+     */
+    public function upsertDocumentsWithIncrease(
+        string $collection,
+        string $attribute,
+        array $documents,
+        ?callable $onNext = null,
+        ?callable $onError = null,
+        int $batchSize = self::INSERT_BATCH_SIZE
+    ): int {
+        if (! $this->adapter->hasFeature(Feature\Upserts::class)) {
+            throw new DatabaseException('Adapter does not support upserts');
+        }
+
+        if (
+            $this->adapter->getSharedTables()
+            && ! $this->adapter->getTenantPerDocument()
+            && empty($this->adapter->getTenant())
+        ) {
+            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
+        }
+
+        if (! $this->adapter->getSharedTables() && $this->adapter->getTenantPerDocument()) {
+            throw new DatabaseException('Shared tables must be enabled if tenant per document is enabled.');
+        }
+
+        if (empty($documents)) {
+            return 0;
+        }
+
+        $batchSize = \min(Database::INSERT_BATCH_SIZE, \max(1, $batchSize));
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        /** @var array<Document> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $time = DateTime::now();
+        $created = 0;
+        $updated = 0;
+        $operatorIds = [];
+        $seenIds = [];
+        foreach ($documents as $key => $document) {
+            if ($this->getSharedTables() && $this->getTenantPerDocument()) {
+                /** @var Document $old */
+                $old = $this->authorization->skip(fn () => $this->withTenant($document->getTenant(), fn () => $this->silent(fn () => $this->getDocument(
+                    $collection->getId(),
+                    $document->getId(),
+                ))));
+            } else {
+                /** @var Document $old */
+                $old = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument(
+                    $collection->getId(),
+                    $document->getId(),
+                )));
+            }
+
+            $document = $this->removeUnknownAttributes($collection, $document);
+
+            // Extract operators early to avoid comparison issues
+            $documentArray = $document->getArrayCopy();
+            $extracted = Operator::extractOperators($documentArray);
+            $operators = $extracted['operators'];
+            $regularUpdates = $extracted['updates'];
+
+            $internalKeys = \array_map(
+                fn (Attribute $attr) => $attr->key,
+                self::internalAttributes()
+            );
+
+            $regularUpdatesUserOnly = \array_diff_key($regularUpdates, \array_flip($internalKeys));
+
+            $skipPermissionsUpdate = true;
+
+            if ($document->offsetExists(Document::PERMISSIONS)) {
+                $originalPermissions = $old->getPermissions();
+                $currentPermissions = $document->getPermissions();
+
+                sort($originalPermissions);
+                sort($currentPermissions);
+
+                $skipPermissionsUpdate = ($originalPermissions === $currentPermissions);
+            }
+
+            // Only skip if no operators and regular attributes haven't changed
+            $hasChanges = false;
+            if (! empty($operators)) {
+                $hasChanges = true;
+            } elseif (! empty($attribute)) {
+                $hasChanges = true;
+            } elseif (! $skipPermissionsUpdate) {
+                $hasChanges = true;
+            } else {
+                // Check if any of the provided attributes differ from old document
+                $oldAttributes = $old->getAttributes();
+                foreach ($regularUpdatesUserOnly as $attrKey => $value) {
+                    $oldValue = $oldAttributes[$attrKey] ?? null;
+                    if ($oldValue != $value) {
+                        $hasChanges = true;
+                        break;
+                    }
+                }
+
+                // Also check if old document has attributes that new document doesn't
+                if (! $hasChanges) {
+                    $internalKeys = \array_map(
+                        fn (Attribute $attr) => $attr->key,
+                        self::internalAttributes()
+                    );
+
+                    $oldUserAttributes = array_diff_key($oldAttributes, array_flip($internalKeys));
+
+                    foreach (array_keys($oldUserAttributes) as $oldAttrKey) {
+                        if (! array_key_exists($oldAttrKey, $regularUpdatesUserOnly)) {
+                            // Old document has an attribute that new document doesn't
+                            $hasChanges = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (! $hasChanges) {
+                // If not updating a single attribute and the document is the same as the old one, skip it
+                unset($documents[$key]);
+
+                continue;
+            }
+
+            // If old is empty, check if user has create permission on the collection
+            // If old is not empty, check if user has update permission on the collection
+            // If old is not empty AND documentSecurity is enabled, check if user has update permission on the collection or document
+
+            if ($old->isEmpty()) {
+                if (! $this->authorization->isValid(new Input(PermissionType::Create, $collection->getCreate()))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            } elseif (! $this->authorization->isValid(new Input(PermissionType::Update, \array_merge(
+                $collection->getUpdate(),
+                ((bool) $documentSecurity ? $old->getUpdate() : [])
+            )))) {
+                throw new AuthorizationException($this->authorization->getDescription());
+            }
+
+            $updatedAt = $document->getUpdatedAt();
+
+            $document
+                ->setAttribute(Document::ID, (empty($document->getId()) || $document->getId() === 'unique()') ? ID::unique() : $document->getId())
+                ->setAttribute(Document::COLLECTION, $collection->getId())
+                ->setAttribute(Document::UPDATED_AT, ($updatedAt === null || ! $this->preserveDates) ? $time : $updatedAt);
+
+            if (! $this->preserveSequence) {
+                $document->removeAttribute(Document::SEQUENCE);
+            }
+
+            $createdAt = $document->getCreatedAt();
+            if ($createdAt === null || ! $this->preserveDates) {
+                $document->setAttribute(Document::CREATED_AT, $old->isEmpty() ? $time : $old->getCreatedAt());
+            } else {
+                $document->setAttribute(Document::CREATED_AT, $createdAt);
+            }
+
+            if ($old->isEmpty()) {
+                $document->setAttribute(Document::VERSION, 1);
+            } else {
+                $oldVersion = $old->getVersion();
+                if ($oldVersion !== null) {
+                    $document->setAttribute(Document::VERSION, $oldVersion + 1);
+                } else {
+                    $document->setAttribute(Document::VERSION, 1);
+                }
+            }
+
+            // Force matching optional parameter sets
+            // Doesn't use decode as that intentionally skips null defaults to reduce payload size
+            foreach ($collectionAttributes as $attr) {
+                /** @var string $attrId */
+                $attrId = $attr[Document::ID];
+                if (! $attr->getAttribute('required') && ! \array_key_exists($attrId, (array) $document)) {
+                    $document->setAttribute(
+                        $attrId,
+                        $old->getAttribute($attrId, ($attr['default'] ?? null))
+                    );
+                }
+            }
+
+            if ($skipPermissionsUpdate) {
+                $document->setAttribute(Document::PERMISSIONS, $old->getPermissions());
+            }
+
+            if ($this->adapter->getSharedTables()) {
+                if ($this->adapter->getTenantPerDocument()) {
+                    if ($document->getTenant() === null) {
+                        throw new DatabaseException('Missing tenant. Tenant must be set when tenant per document is enabled.');
+                    }
+                    if (! $old->isEmpty() && $old->getTenant() !== $document->getTenant()) {
+                        throw new DatabaseException('Tenant cannot be changed.');
+                    }
+                } else {
+                    $document->setAttribute(Document::TENANT, $this->adapter->getTenant());
+                }
+            }
+
+            $document = $this->encode($collection, $document);
+
+            if ($this->validate) {
+                $validator = new Structure(
+                    collection: $collection,
+                    idAttributeType: $this->adapter->getIdAttributeType(),
+                    minAllowedDate: $this->adapter->getMinDateTime(),
+                    maxAllowedDate: $this->adapter->getMaxDateTime(),
+                    supportForAttributes: $this->adapter->supports(Capability::DefinedAttributes),
+                    supportUnsignedBigInt: $this->adapter->supports(Capability::UnsignedBigInt),
+                    currentDocument: $old->isEmpty() ? null : $old
+                );
+
+                if (! $validator->isValid($document)) {
+                    throw new StructureException($validator->getDescription());
+                }
+            }
+
+            if (! $old->isEmpty()) {
+                // Check if document was updated after the request timestamp
+                try {
+                    $oldUpdatedAt = new PhpDateTime($old->getUpdatedAt() ?? 'now');
+                } catch (Exception $e) {
+                    throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+                }
+
+                if (! \is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
+                    throw new ConflictException('Document was updated after the request timestamp');
+                }
+            }
+
+            $hook = $this->relationshipHook;
+            if ($hook?->isEnabled()) {
+                $document = $this->silent(fn () => $hook->afterDocumentCreate($collection, $document));
+            }
+
+            $identity = $this->getDocumentIdentity($document);
+            $seenIds[] = $identity;
+            if (! empty($operators)) {
+                $operatorIds[$identity] = true;
+            }
+            $old = $this->castingBefore($collection, $old);
+            $document = $this->castingBefore($collection, $document);
+
+            $documents[$key] = new Change(
+                old: $old,
+                new: $document
+            );
+        }
+
+        // Required because *some* DBs will allow duplicate IDs for upsert
+        if (\count($seenIds) !== \count(\array_unique($seenIds))) {
+            throw new DuplicateException('Duplicate document IDs found in the input array.');
+        }
+
+        foreach (\array_chunk($documents, $batchSize) as $chunk) {
+            /**
+             * @var array<Change> $chunk
+             */
+            $hasOperators = false;
+            foreach ($chunk as $change) {
+                if (isset($operatorIds[$this->getDocumentIdentity($change->getNew())])) {
+                    $hasOperators = true;
+                    break;
+                }
+            }
+
+            $cacheTarget = $collection->getId() === self::METADATA
+                ? \array_map(static fn (Change $change): Document => $change->getNew(), $chunk)
+                : $collection->getId();
+            $batch = $this->withMutation(
+                Event::DocumentsUpsert,
+                $cacheTarget,
+                function () use ($collection, $attribute, $chunk): array {
+                    if (! $this->adapter->hasFeature(Feature\Upserts::class)) {
+                        throw new DatabaseException('Adapter does not support upserts');
+                    }
+
+                    $adapter = $this->adapter;
+                    $batch = $this->authorization->skip(fn () => $adapter->upsertDocuments(
+                        $collection,
+                        $attribute,
+                        $chunk
+                    ));
+
+                    foreach ($batch as $document) {
+                        $this->withDocumentTenant(
+                            $document,
+                            fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId())
+                        );
+                    }
+
+                    return $batch;
+                }
+            );
+
+            $batch = $this->adapter->getSequences($collection->getId(), $batch);
+
+            foreach ($chunk as $change) {
+                if ($change->getOld()->isEmpty()) {
+                    $created++;
+                } else {
+                    $updated++;
+                }
+            }
+
+            $hook = $this->relationshipHook;
+            if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+                $batch = $this->silent(fn () => $hook->populateDocuments($batch, $collection, $hook->getFetchDepth()));
+            }
+
+            if ($hasOperators) {
+                $batch = $this->refetchDocuments($collection, $batch);
+            }
+
+            /** @var array<Document> $batch */
+            $batch = \array_map(
+                fn (Document $doc) => $hasOperators
+                ? $this->castingAfter($collection, $doc)
+                : $this->decode($collection, $this->castingAfter($collection, $doc)),
+                $batch
+            );
+
+            $batch = $this->decorateDocuments(Event::DocumentsUpsert, $collection, $batch);
+
+            foreach ($batch as $index => $doc) {
+                $old = $chunk[$index]->getOld();
+
+                if (! $old->isEmpty()) {
+                    $old = $this->castingAfter($collection, $old);
+                }
+
+                try {
+                    $onNext && $onNext($doc, $old->isEmpty() ? null : $old);
+                } catch (Throwable $th) {
+                    $onError ? $onError($th) : throw $th;
+                }
+            }
+        }
+
+        $this->triggerHooks(Event::DocumentsUpsert, new Document([
+            Document::COLLECTION => $collection->getId(),
+            'created' => $created,
+            'updated' => $updated,
+        ]));
+
+        return $created + $updated;
+    }
+
+    /**
+     * Increase a document attribute by a value
+     *
+     * @param  string  $collection  The collection ID
+     * @param  string  $id  The document ID
+     * @param  string  $attribute  The attribute to increase
+     * @param  int|float|string  $value  The value to increase the attribute by, can be a float
+     * @param  int|float|string|null  $max  The maximum value the attribute can reach after the increase, null means no limit
+     *
+     * @throws AuthorizationException
+     * @throws DatabaseException
+     * @throws LimitException
+     * @throws NotFoundException
+     * @throws TypeException
+     * @throws Throwable
+     */
+    public function increaseDocumentAttribute(
+        string $collection,
+        string $id,
+        string $attribute,
+        int|float|string $value = 1,
+        int|float|string|null $max = null
+    ): Document {
+        if (! \is_numeric($value) || (\is_string($value) && BigInt::isIntegerString($value)
+            ? BigInt::compare($value, 0) <= 0
+            : (float) $value <= 0)) {
+            throw new InvalidArgumentException('Value must be numeric and greater than 0');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        $numericAttribute = null;
+        if ($this->adapter->supports(Capability::DefinedAttributes)) {
+            /** @var array<Attribute> $allAttrs */
+            $allAttrs = $collection->getAttribute('attributes', []);
+            $matchedAttrs = \array_filter($allAttrs, function (Attribute $a) use ($attribute) {
+                return $a->key === $attribute;
+            });
+
+            if (empty($matchedAttrs)) {
+                throw new NotFoundException('Attribute not found');
+            }
+
+            /** @var Attribute $matchedAttr */
+            $matchedAttr = \end($matchedAttrs);
+            if (! Attribute::isNumericType($matchedAttr->type) || $matchedAttr->array) {
+                throw new TypeException('Attribute must be an integer or float and can not be an array.');
+            }
+            $numericAttribute = $matchedAttr;
+        }
+
+        $cacheTarget = $collection->getId() === self::METADATA
+            ? new Document([Document::ID => $id, Document::COLLECTION => self::METADATA])
+            : $collection->getId();
+        $document = $this->withMutation(Event::DocumentIncrease, $cacheTarget, function () use ($collection, $id, $attribute, $value, $max, $numericAttribute) {
+            /** @var Document $document */
+            $document = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument($collection->getId(), $id, forUpdate: true))); // Skip ensures user does not need read permission for this
+
+            if ($document->isEmpty()) {
+                throw new NotFoundException('Document not found');
+            }
+
+            if ($collection->getId() !== self::METADATA) {
+                $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+                if (! $this->authorization->isValid(new Input(PermissionType::Update, \array_merge(
+                    $collection->getUpdate(),
+                    ((bool) $documentSecurity ? $document->getUpdate() : [])
+                )))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            }
+
+            $attributeExists = $document->offsetExists($attribute);
+            $currentVal = $document->getAttribute($attribute);
+            if ($numericAttribute instanceof Attribute) {
+                $result = $this->getNumericResult($numericAttribute, $currentVal, $value, true);
+            } else {
+                if (! $attributeExists) {
+                    $currentVal = 0;
+                }
+                if (! \is_int($currentVal) && ! \is_float($currentVal)) {
+                    throw new TypeException('Attribute value must be numeric.');
+                }
+                $result = $currentVal + $this->getNativeNumber($value);
+            }
+            $exceedsMaximum = ! \is_null($max) && (
+                $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::compare($result, $max) > 0
+                    : $result > $max
+            );
+            if ($exceedsMaximum) {
+                throw new LimitException('Attribute value exceeds maximum limit: '.$max);
+            }
+
+            $time = DateTime::nowAfter($document->getUpdatedAt());
+            $updatedAt = $document->getUpdatedAt();
+            $updatedAt = (empty($updatedAt) || ! $this->preserveDates) ? $time : DateTime::setTimezone($updatedAt);
+            if ($max !== null) {
+                $max = $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::subtract($max, $value)
+                    : $this->getNativeNumber($max) - $this->getNativeNumber($value);
+            }
+
+            $this->adapter->increaseDocumentAttribute(
+                $collection->getId(),
+                $id,
+                $attribute,
+                $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::toNative($value)
+                    : $this->getNativeNumber($value),
+                $updatedAt,
+                max: $max
+            );
+
+            $this->purgeCachedDocumentInternal($collection->getId(), $id);
+
+            return $document->setAttribute($attribute, $result);
+        });
+
+        $this->triggerHooks(Event::DocumentIncrease, $document);
+
+        return $document;
+    }
+
+    /**
+     * Decrease a document attribute by a value.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The document identifier
+     * @param  string  $attribute  The attribute to decrease
+     * @param  int|float|string  $value  The value to decrease the attribute by, must be positive
+     * @param  int|float|string|null  $min  The minimum value the attribute can reach, null means no limit
+     * @return Document The updated document
+     *
+     * @throws AuthorizationException
+     * @throws DatabaseException
+     */
+    public function decreaseDocumentAttribute(
+        string $collection,
+        string $id,
+        string $attribute,
+        int|float|string $value = 1,
+        int|float|string|null $min = null
+    ): Document {
+        if (! \is_numeric($value) || (\is_string($value) && BigInt::isIntegerString($value)
+            ? BigInt::compare($value, 0) <= 0
+            : (float) $value <= 0)) {
+            throw new InvalidArgumentException('Value must be numeric and greater than 0');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        $numericAttribute = null;
+        if ($this->adapter->supports(Capability::DefinedAttributes)) {
+            /** @var array<Attribute> $decAllAttrs */
+            $decAllAttrs = $collection->getAttribute('attributes', []);
+            $matchedDecAttrs = \array_filter($decAllAttrs, function (Attribute $a) use ($attribute) {
+                return $a->key === $attribute;
+            });
+
+            if (empty($matchedDecAttrs)) {
+                throw new NotFoundException('Attribute not found');
+            }
+
+            /** @var Attribute $matchedDecAttr */
+            $matchedDecAttr = \end($matchedDecAttrs);
+            if (! Attribute::isNumericType($matchedDecAttr->type) || $matchedDecAttr->array) {
+                throw new TypeException('Attribute must be an integer or float and can not be an array.');
+            }
+            $numericAttribute = $matchedDecAttr;
+        }
+
+        $cacheTarget = $collection->getId() === self::METADATA
+            ? new Document([Document::ID => $id, Document::COLLECTION => self::METADATA])
+            : $collection->getId();
+        $document = $this->withMutation(Event::DocumentDecrease, $cacheTarget, function () use ($collection, $id, $attribute, $value, $min, $numericAttribute) {
+            /** @var Document $document */
+            $document = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument($collection->getId(), $id, forUpdate: true))); // Skip ensures user does not need read permission for this
+
+            if ($document->isEmpty()) {
+                throw new NotFoundException('Document not found');
+            }
+
+            if ($collection->getId() !== self::METADATA) {
+                $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+                if (! $this->authorization->isValid(new Input(PermissionType::Update, \array_merge(
+                    $collection->getUpdate(),
+                    ((bool) $documentSecurity ? $document->getUpdate() : [])
+                )))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            }
+
+            $attributeExists = $document->offsetExists($attribute);
+            $currentDecVal = $document->getAttribute($attribute);
+            if ($numericAttribute instanceof Attribute) {
+                $result = $this->getNumericResult($numericAttribute, $currentDecVal, $value, false);
+            } else {
+                if (! $attributeExists) {
+                    $currentDecVal = 0;
+                }
+                if (! \is_int($currentDecVal) && ! \is_float($currentDecVal)) {
+                    throw new TypeException('Attribute value must be numeric.');
+                }
+                $result = $currentDecVal - $this->getNativeNumber($value);
+            }
+            $belowMinimum = ! \is_null($min) && (
+                $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::compare($result, $min) < 0
+                    : $result < $min
+            );
+            if ($belowMinimum) {
+                throw new LimitException('Attribute value exceeds minimum limit: '.$min);
+            }
+
+            $time = DateTime::nowAfter($document->getUpdatedAt());
+            $updatedAt = $document->getUpdatedAt();
+            $updatedAt = (empty($updatedAt) || ! $this->preserveDates) ? $time : DateTime::setTimezone($updatedAt);
+            if ($min !== null) {
+                $min = $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::add($min, $value)
+                    : $this->getNativeNumber($min) + $this->getNativeNumber($value);
+            }
+
+            $this->adapter->increaseDocumentAttribute(
+                $collection->getId(),
+                $id,
+                $attribute,
+                $numericAttribute instanceof Attribute && Attribute::isIntegerType($numericAttribute->type)
+                    ? BigInt::negate($value)
+                    : $this->getNativeNumber($value) * -1,
+                $updatedAt,
+                min: $min
+            );
+
+            $this->purgeCachedDocumentInternal($collection->getId(), $id);
+
+            return $document->setAttribute($attribute, $result);
+        });
+
+        $this->triggerHooks(Event::DocumentDecrease, $document);
+
+        return $document;
+    }
+
+    /**
+     * Delete Document
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The document identifier
+     * @return bool True if the document was deleted successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws RestrictedException
+     */
+    public function deleteDocument(string $collection, string $id): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        $cacheTarget = $collection->getId() === self::METADATA
+            ? new Document([Document::ID => $id, Document::COLLECTION => self::METADATA])
+            : $collection->getId();
+        $deleted = $this->withMutation(Event::DocumentDelete, $cacheTarget, function () use ($collection, $id, &$document) {
+            $document = $this->authorization->skip(fn () => $this->silent(
+                fn () => $this->getDocument($collection->getId(), $id, forUpdate: true)
+            ));
+
+            if ($document->isEmpty()) {
+                return false;
+            }
+
+            if ($collection->getId() !== self::METADATA) {
+                $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+                if (! $this->authorization->isValid(new Input(PermissionType::Delete, [
+                    ...$collection->getDelete(),
+                    ...($documentSecurity ? $document->getDelete() : []),
+                ]))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            }
+
+            // Check if document was updated after the request timestamp
+            try {
+                $oldUpdatedAt = new PhpDateTime($document->getUpdatedAt() ?? 'now');
+            } catch (Exception $e) {
+                throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+            }
+
+            if (! \is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
+                throw new ConflictException('Document was updated after the request timestamp');
+            }
+
+            if ($this->relationshipHook?->isEnabled()) {
+                $document = $this->silent(fn () => $this->relationshipHook->beforeDocumentDelete($collection, $document));
+            }
+
+            $result = $this->authorization->skip(fn () => $this->adapter->deleteDocument($collection->getId(), $id));
+
+            $this->purgeCachedDocumentInternal($collection->getId(), $id);
+
+            return $result;
+        });
+
+        if ($deleted) {
+            $this->triggerHooks(Event::DocumentDelete, $document);
+        }
+
+        return $deleted;
+    }
+
+    /**
+     * Delete Documents
+     *
+     * Deletes all documents which match the given queries, respecting relationship onDelete options.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Query>  $queries  Queries to filter documents for deletion
+     * @param  int  $batchSize  Number of documents per batch deletion
+     * @param  (callable(Document, Document): void)|null  $onNext  Callback invoked for each deleted document
+     * @param  (callable(Throwable): void)|null  $onError  Callback invoked on per-document errors
+     * @return int The number of documents deleted
+     *
+     * @throws AuthorizationException
+     * @throws DatabaseException
+     * @throws RestrictedException
+     * @throws Throwable
+     */
+    public function deleteDocuments(
+        string $collection,
+        array $queries = [],
+        int $batchSize = self::DELETE_BATCH_SIZE,
+        ?callable $onNext = null,
+        ?callable $onError = null,
+    ): int {
+        if ($this->adapter->getSharedTables() && empty($this->adapter->getTenant())) {
+            throw new DatabaseException('Missing tenant. Tenant must be set when table sharing is enabled.');
+        }
+
+        $batchSize = \min(Database::DELETE_BATCH_SIZE, \max(1, $batchSize));
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        if ($collection->isEmpty()) {
+            throw new DatabaseException('Collection not found');
+        }
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        $skipAuth = $this->authorization->isValid(new Input(PermissionType::Delete, $collection->getDelete()));
+
+        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+            throw new AuthorizationException($this->authorization->getDescription());
+        }
+
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = $this->getDocumentsValidator($collection);
+
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        $grouped = Query::groupForDatabase($queries);
+        $limit = $grouped['limit'];
+        $cursor = $grouped['cursor'];
+
+        if (! empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
+            throw new DatabaseException('Cursor document must be from the same Collection.');
+        }
+
+        $originalLimit = $limit;
+        $last = $cursor;
+        $modified = 0;
+
+        while (true) {
+            if ($limit && $limit < $batchSize && $limit > 0) {
+                $batchSize = $limit;
+            } elseif (! empty($limit)) {
+                $limit -= $batchSize;
+            }
+
+            $new = [
+                Query::limit($batchSize),
+            ];
+
+            if (! empty($last)) {
+                $new[] = Query::cursorAfter($last);
+            }
+
+            /**
+             * @var array<Document> $batch
+             */
+            $batch = $this->silent(fn () => $this->find(
+                $collection->getId(),
+                array_merge($new, $queries),
+                forPermission: PermissionType::Delete
+            ));
+
+            if (empty($batch)) {
+                break;
+            }
+
+            $old = array_map(fn ($doc) => clone $doc, $batch);
+            $sequences = [];
+            $permissionIds = [];
+
+            $cacheTarget = $collection->getId() === self::METADATA ? $batch : $collection->getId();
+            $this->withMutation(Event::DocumentsDelete, $cacheTarget, function () use ($collection, $sequences, $permissionIds, $batch) {
+                foreach ($batch as $document) {
+                    $seq = $document->getSequence();
+                    if ($seq !== null) {
+                        $sequences[] = $seq;
+                    }
+                    if (! empty($document->getPermissions())) {
+                        $permissionIds[] = $document->getId();
+                    }
+
+                    if ($this->relationshipHook?->isEnabled()) {
+                        $document = $this->silent(fn () => $this->relationshipHook->beforeDocumentDelete(
+                            $collection,
+                            $document
+                        ));
+                    }
+
+                    // Check if document was updated after the request timestamp
+                    try {
+                        $oldUpdatedAt = new PhpDateTime($document->getUpdatedAt() ?? 'now');
+                    } catch (Exception $e) {
+                        throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+                    }
+
+                    if (! \is_null($this->timestamp) && $oldUpdatedAt > $this->timestamp) {
+                        throw new ConflictException('Document was updated after the request timestamp');
+                    }
+                }
+
+                $this->adapter->deleteDocuments(
+                    $collection->getId(),
+                    $sequences,
+                    $permissionIds
+                );
+
+                foreach ($batch as $document) {
+                    $this->withDocumentTenant(
+                        $document,
+                        fn () => $this->purgeCachedDocumentInternal($collection->getId(), $document->getId())
+                    );
+                }
+            });
+
+            foreach ($batch as $index => $document) {
+                try {
+                    $onNext && $onNext($document, $old[$index]);
+                } catch (Throwable $th) {
+                    $onError ? $onError($th) : throw $th;
+                }
+                $modified++;
+            }
+
+            if (count($batch) < $batchSize) {
+                break;
+            } elseif ($originalLimit && $modified >= $originalLimit) {
+                break;
+            }
+
+            $last = \end($batch);
+        }
+
+        $this->triggerHooks(Event::DocumentsDelete, new Document([
+            Document::COLLECTION => $collection->getId(),
+            'modified' => $modified,
+        ]));
+
+        return $modified;
+    }
+
+    /**
+     * Cleans all of the collection's documents from the cache and all related cached documents.
+     *
+     * @param  string  $collectionId  The collection identifier
+     * @return bool True if the cache was purged successfully
+     */
+    public function purgeCachedCollection(string $collectionId): bool
+    {
+        [$collectionKey] = $this->getCacheKeys($collectionId);
+
+        return $this->advanceDocumentCacheEpoch($collectionKey);
+    }
+
+    /**
+     * Cleans a specific document from cache
+     * And related document reference in the collection cache.
+     *
+     * @throws Exception
+     */
+    protected function purgeCachedDocumentInternal(string $collectionId, ?string $id): bool
+    {
+        if ($id === null) {
+            return true;
+        }
+
+        [$collectionKey] = $this->getCacheKeys($collectionId, $id);
+
+        return $this->advanceDocumentCacheEpoch($collectionKey);
+    }
+
+    private function getDocumentCacheEpoch(string $collectionKey): ?string
+    {
+        $epochKey = $collectionKey.'#epoch';
+
+        try {
+            $epoch = $this->cache->load($epochKey, self::TTL);
+            if ($epoch === false || $epoch === null) {
+                $epoch = \bin2hex(\random_bytes(16));
+                if ($this->cache->save($epochKey, $epoch) === false) {
+                    return null;
+                }
+            }
+
+            return \is_string($epoch) && $epoch !== '' ? $epoch : null;
+        } catch (Throwable $error) {
+            Console::warning('Warning: Failed to load document cache epoch: '.$error->getMessage());
+
+            return null;
+        }
+    }
+
+    private function advanceDocumentCacheEpoch(string $collectionKey): bool
+    {
+        $epochKey = $collectionKey.'#epoch';
+        $this->cache->purge($epochKey);
+        $this->cache->save($epochKey, \bin2hex(\random_bytes(16)));
+
+        return true;
+    }
+
+    /**
+     * Run a cache operation under the document's tenant when tenant-per-document is enabled.
+     *
+     * @param  callable(): mixed  $callback
+     */
+    private function withDocumentTenant(Document $document, callable $callback): void
+    {
+        if ($this->getSharedTables() && $this->getTenantPerDocument()) {
+            $this->withTenant($document->getTenant(), $callback);
+
+            return;
+        }
+
+        $callback();
+    }
+
+    private function getDocumentIdentity(Document $document): string
+    {
+        if (! $this->adapter->getTenantPerDocument()) {
+            return $document->getId();
+        }
+
+        return ($document->getTenant() ?? '').'\0'.$document->getId();
+    }
+
+    /**
+     * Cleans a specific document from cache and triggers Event::DocumentPurge.
+     *
+     * Note: Do not retry this method as it triggers events. Use purgeCachedDocumentInternal() with retry instead.
+     *
+     * @param  string  $collectionId  The collection identifier
+     * @param  string|null  $id  The document identifier, or null to skip
+     * @return bool True if the cache was purged successfully
+     *
+     * @throws Exception
+     */
+    public function purgeCachedDocument(string $collectionId, ?string $id): bool
+    {
+        $result = $this->purgeCachedDocumentInternal($collectionId, $id);
+
+        if ($id !== null) {
+            $this->trigger(Event::DocumentPurge, new Document([
+                Document::ID => $id,
+                Document::COLLECTION => $collectionId,
+            ]));
+        }
+
+        return $result;
+    }
+
+    /**
+     * Purge all cached query entries for a collection namespace.
+     */
+    public function purgeCachedQueries(string $collection, ?string $namespace = null): bool
+    {
+        $collectionDocument = $this->silent(fn () => $this->getCollection($collection));
+        $collection = $collectionDocument->isEmpty() ? $collection : $collectionDocument->getId();
+        $epochKey = $this->getQueryCacheKey($collection, $namespace).'#epoch';
+        $existing = $this->cache->load($epochKey, self::TTL);
+
+        if ($existing !== false && $existing !== null && ! $this->cache->purge($epochKey)) {
+            return false;
+        }
+
+        return $this->cache->save($epochKey, \bin2hex(\random_bytes(16))) !== false;
+    }
+
+    /**
+     * Execute a callback behind a generation-protected cache-aside lookup.
+     *
+     * @template T
+     * @param  callable(): T  $callback
+     * @return T
+     *
+     * @throws AuthorizationException
+     */
+    public function withCache(
+        string $key,
+        callable $callback,
+        ?string $hash = '',
+    ): mixed {
+        if ($hash === null || $this->adapter->inTransaction()) {
+            return $callback();
+        }
+
+        $epochKey = $key.'#epoch';
+        try {
+            $epoch = $this->cache->load($epochKey, self::TTL);
+            if ($epoch === false || $epoch === null) {
+                $epoch = \bin2hex(\random_bytes(16));
+                if ($this->cache->save($epochKey, $epoch) === false) {
+                    return $callback();
+                }
+            }
+            if (! \is_string($epoch) || $epoch === '') {
+                return $callback();
+            }
+        } catch (Throwable $error) {
+            Console::warning('Warning: Failed to load cache epoch: '.$error->getMessage());
+
+            return $callback();
+        }
+
+        $physicalKey = $key.'#'.$epoch.':'.$hash;
+
+        $shouldRefreshCache = false;
+
+        try {
+            $cached = $this->cache->load($physicalKey, self::TTL);
+        } catch (Throwable $error) {
+            Console::warning('Warning: Failed to load cache value: '.$error->getMessage());
+            $cached = false;
+        }
+
+        if ($cached !== false && $cached !== null) {
+            $cachedValue = \is_array($cached) && \array_key_exists('value', $cached)
+                ? $cached['value']
+                : false;
+
+            if ($cachedValue !== false) {
+                $decoded = $cachedValue;
+                $collectionId = $cached['collection'] ?? null;
+
+                if (\is_string($collectionId) && $collectionId !== '') {
+                    $collection = $this->silent(fn () => $this->getCollection($collectionId));
+
+                    if ($collection->isEmpty()) {
+                        $decoded = false;
+                    } else {
+                        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+                        $skipAuth = $this->authorization->isValid(new Input(PermissionType::Read, $collection->getRead()));
+
+                        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+                            throw new AuthorizationException($this->authorization->getDescription());
+                        }
+
+                        $type = $cached['type'] ?? null;
+                        $payload = $type === 'document' ? [$cachedValue] : $cachedValue;
+
+                        if (! \is_array($payload)) {
+                            $decoded = false;
+                        } else {
+                            $documents = [];
+
+                            foreach ($payload as $item) {
+                                if (! \is_array($item)) {
+                                    $decoded = false;
+                                    break;
+                                }
+
+                                /** @var array<string, mixed> $item */
+                                $document = $this->createDocumentInstance($collection->getId(), $item);
+                                $document = $this->casting($collection, $document);
+
+                                if ($this->isTtlExpired($collection, $document)) {
+                                    $decoded = false;
+                                    break;
+                                }
+
+                                if (! $skipAuth && $documentSecurity && $collection->getId() !== self::METADATA) {
+                                    if (! $this->authorization->isValid(new Input(PermissionType::Read, $document->getRead()))) {
+                                        if ($type === 'document') {
+                                            $decoded = false;
+                                            break;
+                                        }
+
+                                        continue;
+                                    }
+                                }
+
+                                $documents[] = $document;
+                            }
+
+                            if ($decoded !== false) {
+                                $decoded = $type === 'document' ? ($documents[0] ?? false) : $documents;
+                            }
+                        }
+                    }
+                }
+
+                if ($decoded !== false) {
+                    return $decoded;
+                }
+            }
+
+            $shouldRefreshCache = true;
+        }
+
+        if ($shouldRefreshCache) {
+            try {
+                $this->cache->purge($physicalKey);
+            } catch (Throwable $error) {
+                Console::warning('Warning: Failed to purge rejected cache value: '.$error->getMessage());
+            }
+        }
+
+        $generation = '0';
+        try {
+            $generation = $this->cache->getGeneration($physicalKey);
+        } catch (Throwable $error) {
+            Console::warning('Warning: Failed to get cache generation: '.$error->getMessage());
+        }
+
+        $callbackValue = $callback();
+
+        if ($callbackValue !== false) {
+            try {
+                $encoded = $this->encodeCacheValue($callbackValue);
+
+                if ($encoded !== false) {
+                    $this->cache->saveWithLease($physicalKey, $encoded, '', $generation);
+                }
+            } catch (Throwable $error) {
+                Console::warning('Warning: Failed to save cache value: '.$error->getMessage());
+            }
+        }
+
+        /** @var T $callbackValue */
+        return $callbackValue;
+    }
+
+    /**
+     * @return array<string, mixed>|false
+     */
+    private function encodeCacheValue(mixed $value): array|false
+    {
+        if ($value instanceof Document) {
+            $collection = $value->getCollection();
+
+            return $collection === '' ? false : [
+                'collection' => $collection,
+                'type' => 'document',
+                'value' => $value->getArrayCopy(),
+            ];
+        }
+
+        if (! \is_array($value)) {
+            return ['value' => $value];
+        }
+
+        $collection = null;
+        $documents = [];
+        $hasDocuments = false;
+        $hasNonDocuments = false;
+
+        foreach ($value as $item) {
+            if (! $item instanceof Document) {
+                if ($hasDocuments || $this->containsDocument($item)) {
+                    return false;
+                }
+
+                $hasNonDocuments = true;
+                continue;
+            }
+
+            if ($hasNonDocuments) {
+                return false;
+            }
+
+            $documentCollection = $item->getCollection();
+            if ($documentCollection === '' || ($collection !== null && $collection !== $documentCollection)) {
+                return false;
+            }
+
+            $collection = $documentCollection;
+            $hasDocuments = true;
+            $documents[] = $item->getArrayCopy();
+        }
+
+        return $hasDocuments ? [
+            'collection' => $collection,
+            'type' => 'documents',
+            'value' => $documents,
+        ] : ['value' => $value];
+    }
+
+    private function containsDocument(mixed $value): bool
+    {
+        if ($value instanceof Document) {
+            return true;
+        }
+
+        if (! \is_array($value)) {
+            return false;
+        }
+
+        foreach ($value as $item) {
+            if ($this->containsDocument($item)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Find Documents
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Query>  $queries  Queries for filtering, sorting, pagination, and selection
+     * @param  PermissionType  $forPermission  The permission type to check for authorization
+     * @return array<Document>
+     *
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     * @throws QueryException
+     * @throws TimeoutException
+     * @throws Exception
+     */
+    public function find(string $collection, array $queries = [], PermissionType $forPermission = PermissionType::Read): array
+    {
+        $queryCacheQueries = $queries;
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = $this->getDocumentsValidator($collection);
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        $skipAuth = $this->authorization->isValid(new Input($forPermission, $collection->getPermissionsByType($forPermission)));
+
+        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+            throw new AuthorizationException($this->authorization->getDescription());
+        }
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            fn (Attribute|Document $attribute) => Attribute::isRelationship($attribute)
+        );
+
+        $grouped = Query::groupForDatabase($queries);
+        $filters = $grouped['filters'];
+        $selects = $grouped['selections'];
+        $aggregations = $grouped['aggregations'];
+        $groupByAttrs = $grouped['groupBy'];
+        $having = $grouped['having'];
+        $joins = $grouped['joins'];
+        if (! empty($joins)) {
+            $skipAuth = false;
+        }
+        $distinct = $grouped['distinct'];
+        $limit = $grouped['limit'];
+        $offset = $grouped['offset'];
+        $orderAttributes = $grouped['orderAttributes'];
+        $orderTypes = $grouped['orderTypes'];
+        $cursor = $grouped['cursor'];
+        $cursorDirection = $grouped['cursorDirection'] ?? CursorDirection::After;
+
+        $isAggregation = ! empty($aggregations) || ! empty($groupByAttrs);
+
+        if ($isAggregation && ! $this->adapter->supports(Capability::Aggregations)) {
+            throw new QueryException('Aggregation queries are not supported by this adapter');
+        }
+
+        if (! empty($joins) && ! $this->adapter->supports(Capability::Joins)) {
+            throw new QueryException('Join queries are not supported by this adapter');
+        }
+
+        $joinDocumentSecurity = [];
+        if (! empty($joins)) {
+            $joinDocumentSecurity = $this->authorizeJoins($joins, $forPermission);
+        }
+
+        if (! $isAggregation && ! $distinct) {
+            $uniqueOrderBy = false;
+            foreach ($orderAttributes as $order) {
+                if ($order === Document::ID || $order === Document::SEQUENCE) {
+                    $uniqueOrderBy = true;
+                }
+            }
+
+            if ($uniqueOrderBy === false) {
+                $leadingAttribute = $orderAttributes[0] ?? null;
+                $leadingOrderType = $orderTypes[0] ?? \Utopia\Query\OrderDirection::Asc;
+
+                if (\in_array($leadingAttribute, [Document::CREATED_AT, Document::UPDATED_AT], true)) {
+                    \array_splice($orderAttributes, 1, 0, [Document::SEQUENCE]);
+                    \array_splice($orderTypes, 1, 0, [$leadingOrderType]);
+                } else {
+                    $orderAttributes[] = Document::SEQUENCE;
+                    $orderTypes[] = \Utopia\Query\OrderDirection::Asc;
+                }
+            }
+        }
+
+        if (! empty($cursor)) {
+            if ($isAggregation) {
+                throw new QueryException('Cursor pagination is not supported with aggregation queries');
+            }
+
+            foreach ($orderAttributes as $order) {
+                if ($this->cursorOrderValue($cursor, $order) === null) {
+                    throw new OrderException(
+                        message: "Order attribute '{$order}' is empty",
+                        attribute: $order
+                    );
+                }
+            }
+        }
+
+        if (! empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
+            throw new DatabaseException('cursor Document must be from the same Collection.');
+        }
+
+        if (! empty($cursor)) {
+            $cursor = $this->encode($collection, $cursor);
+            $cursor = $this->castingBefore($collection, $cursor);
+            $cursor = $cursor->getArrayCopy();
+            foreach ($orderAttributes as $order) {
+                if (\array_key_exists($order, $cursor) && $cursor[$order] !== null) {
+                    continue;
+                }
+                $bare = $this->bareOrderAttribute($order);
+                if ($bare !== $order && \array_key_exists($bare, $cursor) && $cursor[$bare] !== null) {
+                    $cursor[$order] = $cursor[$bare];
+                }
+            }
+        } else {
+            $cursor = [];
+        }
+
+        /** @var array<Query> $queries */
+        $queries = \array_merge(
+            $selects,
+            $this->convertQueries($collection, $filters),
+            $aggregations,
+            $having,
+            $joins,
+        );
+
+        if (! empty($groupByAttrs)) {
+            $queries[] = Query::groupBy($groupByAttrs);
+        }
+
+        if ($distinct) {
+            $queries[] = Query::distinct();
+        }
+
+        $selections = $this->validateSelections($collection, $selects);
+
+        if ($isAggregation) {
+            $nestedSelections = [];
+        } else {
+            $nestedSelections = $this->relationshipHook?->processQueries($relationships, $queries) ?? [];
+        }
+
+        // Convert relationship filter queries to SQL-level subqueries
+        if (! $isAggregation) {
+            $convertedQueries = $this->relationshipHook !== null
+                ? $this->relationshipHook->convertQueries($relationships, $queries, $collection)
+                : $queries;
+        } else {
+            $convertedQueries = $queries;
+        }
+
+        // If conversion returns null, it means no documents can match (relationship filter found no matches)
+        if ($convertedQueries === null) {
+            $results = [];
+        } else {
+            $queries = $convertedQueries;
+
+            $cacheKey = null;
+            $cacheGeneration = '0';
+            if (
+                $this->queryCache !== null
+                && $this->adapter->supports(Capability::Caching)
+                && ! $this->adapter->inTransaction()
+                && empty($joins)
+                && $this->queryCache->isEnabled($collection->getId())
+            ) {
+                $cacheContext = $skipAuth
+                    ? $this->authorization->skip(fn () => $this->getQueryCacheField($collection, $queryCacheQueries, forPermission: $forPermission))
+                    : $this->getQueryCacheField($collection, $queryCacheQueries, forPermission: $forPermission);
+
+                if ($cacheContext !== null) {
+                    $cacheContext .= ':'.($this->adapter->supports(Capability::Hostname) ? $this->adapter->getHostname() : '');
+                }
+
+                if ($cacheContext !== null) {
+                    $cacheKey = $this->queryCache->buildQueryKey(
+                        $collection->getId(),
+                        [
+                            'input' => \array_map(
+                                fn (Query $query): array => $this->serializeQueryCacheQuery($query),
+                                $queryCacheQueries,
+                            ),
+                            'queries' => \array_map(
+                                fn (Query $query): array => $this->serializeQueryCacheQuery($query),
+                                $queries,
+                            ),
+                            'limit' => $limit ?? 25,
+                            'offset' => $offset ?? 0,
+                            'orderAttributes' => $orderAttributes,
+                            'orderTypes' => \array_map(
+                                static fn (\Utopia\Query\OrderDirection $direction): string => $direction->value,
+                                $orderTypes,
+                            ),
+                            'cursor' => $this->normalizeQueryCacheQueryValue($cursor),
+                            'cursorDirection' => $cursorDirection->value,
+                        ],
+                        $this->adapter->getNamespace(),
+                        $this->adapter->getTenant(),
+                        $cacheContext,
+                    );
+                    $cacheGeneration = $this->queryCache->getGeneration($cacheKey);
+                    $cached = $this->queryCache->get($cacheKey);
+                    if ($cached !== null) {
+                        $results = $cached;
+                        $cacheKey = null;
+                    }
+                }
+            }
+
+            if (! isset($results)) {
+                $adapterCollection = $this->withJoinDocumentSecurity($collection, $joinDocumentSecurity);
+
+                // Inline the auth-skip toggle to avoid the per-find Closure
+                // allocation that authorization->skip() requires. Mirrors
+                // Authorization::skip's restore semantics: the previous status
+                // is reapplied unconditionally so any nested toggle inside the
+                // try block cannot leak past this scope.
+                if ($skipAuth) {
+                    $previousStatus = $this->authorization->getStatus();
+                    $this->authorization->disable();
+                    try {
+                        $results = $this->adapter->find(
+                            $adapterCollection,
+                            $queries,
+                            $limit ?? 25,
+                            $offset ?? 0,
+                            $orderAttributes,
+                            $orderTypes,
+                            $cursor,
+                            $cursorDirection,
+                            $forPermission
+                        );
+                    } finally {
+                        $this->authorization->setStatus($previousStatus);
+                    }
+                } else {
+                    $results = $this->adapter->find(
+                        $adapterCollection,
+                        $queries,
+                        $limit ?? 25,
+                        $offset ?? 0,
+                        $orderAttributes,
+                        $orderTypes,
+                        $cursor,
+                        $cursorDirection,
+                        $forPermission
+                    );
+                }
+
+                if ($cacheKey !== null && $this->queryCache !== null) {
+                    $this->queryCache->set($cacheKey, $results, $cacheGeneration);
+                }
+            }
+        }
+
+        if ($isAggregation) {
+            $this->trigger(Event::DocumentFind, $results);
+
+            return $results;
+        }
+
+        $hook = $this->relationshipHook;
+        if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled() && ! empty($relationships) && (empty($selects) || ! empty($nestedSelections))) {
+            if (count($results) > 0) {
+                $results = $this->silent(fn () => $hook->populateDocuments($results, $collection, $hook->getFetchDepth(), $nestedSelections));
+            }
+        }
+
+        // Hoist invariants out of the per-document loop. Collection id and
+        // documentType lookup don't change per result row, but were being
+        // re-evaluated for every document on every find.
+        $collectionId = $collection->getId();
+        $hasCustomType = isset($this->documentTypes[$collectionId]);
+
+        foreach ($results as $index => $node) {
+            $node = $this->castingAfter($collection, $node);
+            $node = $this->casting($collection, $node);
+            $node = $this->decode($collection, $node, $selections);
+
+            // Convert to custom document type if mapped
+            if ($hasCustomType) {
+                $node = $this->createDocumentInstance($collectionId, $node->getArrayCopy());
+            }
+
+            if (! $node->isEmpty()) {
+                $node->setAttribute(Document::COLLECTION, $collectionId);
+            }
+
+            $results[$index] = $node;
+        }
+
+        $results = $this->decorateDocuments(Event::DocumentFind, $collection, $results);
+
+        if ($collection->getId() === self::METADATA) {
+            foreach ($results as $index => $node) {
+                $results[$index] = $this->hydrateCollectionModels($node);
+            }
+        }
+
+        $this->trigger(Event::DocumentFind, $results);
+
+        return $results;
+    }
+
+    /**
+     * Execute a raw query bypassing the query builder.
+     *
+     * @param string $query The raw query string
+     * @param array<mixed> $bindings Parameter bindings
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     */
+    public function rawQuery(string $query, array $bindings = []): array
+    {
+        if (! $this->adapter->hasFeature(Feature\RawQuery::class)) {
+            throw new DatabaseException('Raw queries are not supported by this adapter');
+        }
+
+        return $this->adapter->rawQuery($query, $bindings);
+    }
+
+    /**
+     * Iterate documents in collection using a callback pattern.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  callable(Document): void  $callback  Callback invoked for each matching document
+     * @param  array<Query>  $queries  Queries for filtering, sorting, and pagination
+     * @param  PermissionType  $forPermission  The permission type to check for authorization
+     *
+     * @throws DatabaseException
+     */
+    public function foreach(string $collection, callable $callback, array $queries = [], PermissionType $forPermission = PermissionType::Read): void
+    {
+        foreach ($this->iterate($collection, $queries, $forPermission) as $document) {
+            $callback($document);
+        }
+    }
+
+    /**
+     * Return a generator yielding each document of the given collection that matches the given queries.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Query>  $queries  Queries for filtering, sorting, and pagination
+     * @param  PermissionType  $forPermission  The permission type to check for authorization
+     * @return Generator<Document>
+     *
+     * @throws DatabaseException
+     */
+    public function iterate(string $collection, array $queries = [], PermissionType $forPermission = PermissionType::Read): Generator
+    {
+        $grouped = Query::groupForDatabase($queries);
+        $limitExists = $grouped['limit'] !== null;
+        $limit = $grouped['limit'] ?? 25;
+        $offset = $grouped['offset'];
+
+        $cursor = $grouped['cursor'];
+        $cursorDirection = $grouped['cursorDirection'];
+
+        // Cursor before is not supported
+        if ($cursor !== null && $cursorDirection === CursorDirection::Before) {
+            throw new DatabaseException('Cursor '.CursorDirection::Before->value.' not supported in this method.');
+        }
+
+        $sum = $limit;
+        $latestDocument = null;
+
+        while ($sum === $limit) {
+            $newQueries = $queries;
+            if ($latestDocument !== null) {
+                // reset offset and cursor as groupByType ignores same type query after first one is encountered
+                if ($offset !== null) {
+                    array_unshift($newQueries, Query::offset(0));
+                }
+
+                array_unshift($newQueries, Query::cursorAfter($latestDocument));
+            }
+            if (! $limitExists) {
+                $newQueries[] = Query::limit($limit);
+            }
+            $results = $this->find($collection, $newQueries, $forPermission);
+
+            if (empty($results)) {
+                return;
+            }
+
+            $sum = count($results);
+
+            foreach ($results as $document) {
+                yield $document;
+            }
+
+            $latestDocument = $results[array_key_last($results)];
+        }
+    }
+
+    /**
+     * Find a single document matching the given queries.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Query>  $queries  Queries for filtering
+     * @return Document The matching document, or an empty Document if none found
+     *
+     * @throws DatabaseException
+     */
+    public function findOne(string $collection, array $queries = []): Document
+    {
+        $results = $this->silent(fn () => $this->find($collection, \array_merge([
+            Query::limit(1),
+        ], $queries)));
+
+        $found = \reset($results);
+
+        $this->trigger(Event::DocumentFind, $found);
+
+        if (! $found) {
+            return new Document();
+        }
+
+        return $found;
+    }
+
+    /**
+     * Count Documents
+     *
+     * Count the number of documents matching the given queries.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  array<Query>  $queries  Queries for filtering
+     * @param  int|null  $max  Maximum count to return, null for unlimited
+     * @return int The document count
+     *
+     * @throws DatabaseException
+     */
+    public function count(string $collection, array $queries = [], ?int $max = null): int
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = $this->getDocumentsValidator($collection);
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        $skipAuth = $this->authorization->isValid(new Input(PermissionType::Read, $collection->getRead()));
+
+        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+            throw new AuthorizationException($this->authorization->getDescription());
+        }
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            fn (Attribute|Document $attribute) => Attribute::isRelationship($attribute)
+        );
+
+        $prepared = $this->prepareFilterJoinQueries($collection, $queries, $relationships, $skipAuth);
+        if ($prepared === null) {
+            return 0;
+        }
+
+        [$collection, $queries, $skipAuth] = $prepared;
+
+        $getCount = fn () => $this->adapter->count($collection, $queries, $max);
+        $count = $skipAuth ? $this->authorization->skip($getCount) : $getCount();
+
+        $this->trigger(Event::DocumentCount, $count);
+
+        return $count;
+    }
+
+    /**
+     * Sum an attribute
+     *
+     * Sum an attribute for all matching documents. Pass $max=0 for unlimited.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $attribute  The attribute to sum
+     * @param  array<Query>  $queries  Queries for filtering
+     * @param  int|null  $max  Maximum number of documents to include in the sum
+     * @return float|int The sum of the attribute values
+     *
+     * @throws DatabaseException
+     */
+    public function sum(string $collection, string $attribute, array $queries = [], ?int $max = null): float|int
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        /** @var array<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueryTypes($queries);
+
+        if ($this->validate) {
+            $validator = $this->getDocumentsValidator($collection);
+            if (! $validator->isValid($queries)) {
+                throw new QueryException($validator->getDescription());
+            }
+        }
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+        $skipAuth = $this->authorization->isValid(new Input(PermissionType::Read, $collection->getRead()));
+
+        if (! $skipAuth && ! $documentSecurity && $collection->getId() !== self::METADATA) {
+            throw new AuthorizationException($this->authorization->getDescription());
+        }
+
+        /** @var array<Document> $relationships */
+        $relationships = \array_filter(
+            $attributes,
+            fn (Attribute|Document $attribute) => Attribute::isRelationship($attribute)
+        );
+
+        $prepared = $this->prepareFilterJoinQueries($collection, $queries, $relationships, $skipAuth);
+        if ($prepared === null) {
+            return 0;
+        }
+
+        [$collection, $queries, $skipAuth] = $prepared;
+
+        $getSum = fn () => $this->adapter->sum($collection, $attribute, $queries, $max);
+        $sum = $skipAuth ? $this->authorization->skip($getSum) : $getSum();
+
+        $this->trigger(Event::DocumentSum, $sum);
+
+        return $sum;
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return Generator<int, Document>
+     */
+    public function cursor(string $collection, array $queries = [], int $batchSize = 100): Generator
+    {
+        $lastDocument = null;
+
+        while (true) {
+            $batchQueries = $queries;
+            $batchQueries[] = Query::limit($batchSize);
+
+            if ($lastDocument !== null) {
+                $batchQueries[] = Query::cursorAfter($lastDocument);
+            }
+
+            $documents = $this->find($collection, $batchQueries);
+
+            if ($documents === []) {
+                break;
+            }
+
+            foreach ($documents as $document) {
+                yield $document;
+            }
+
+            $lastDocument = \end($documents);
+
+            if (\count($documents) < $batchSize) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Execute aggregation queries (count, sum, avg, min, max, groupBy) and return results.
+     *
+     * @param  array<Query>  $queries  Must include at least one aggregation query (Query::count(), Query::sum(), etc.)
+     * @return array<Document>
+     */
+    public function aggregate(string $collection, array $queries): array
+    {
+        return $this->find($collection, $queries);
+    }
+
+    private function cursorOrderValue(Document $cursor, string $order): mixed
+    {
+        $value = $cursor->getAttribute($order);
+        if ($value !== null) {
+            return $value;
+        }
+
+        $bare = $this->bareOrderAttribute($order);
+        if ($bare === $order) {
+            return null;
+        }
+
+        return $cursor->getAttribute($bare);
+    }
+
+    private function bareOrderAttribute(string $order): string
+    {
+        $dot = \strrpos($order, '.');
+        if ($dot === false) {
+            return $order;
+        }
+
+        return \substr($order, $dot + 1);
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @param  array<Document>  $relationships
+     * @return array{0: Document, 1: array<Query>, 2: bool}|null
+     */
+    private function prepareFilterJoinQueries(
+        Document $collection,
+        array $queries,
+        array $relationships,
+        bool $skipAuth,
+    ): ?array {
+        $grouped = Query::groupForDatabase($queries);
+        $filters = $grouped['filters'];
+        $joins = $grouped['joins'];
+
+        if (! empty($joins)) {
+            $skipAuth = false;
+
+            if (! $this->adapter->supports(Capability::Joins)) {
+                throw new QueryException('Join queries are not supported by this adapter');
+            }
+
+            $collection = $this->withJoinDocumentSecurity(
+                $collection,
+                $this->authorizeJoins($joins, PermissionType::Read),
+            );
+        }
+
+        $queries = \array_merge(
+            $this->convertQueries($collection, $filters),
+            $joins,
+        );
+
+        $convertedQueries = $this->relationshipHook !== null
+            ? $this->relationshipHook->convertQueries($relationships, $queries, $collection)
+            : $queries;
+
+        if ($convertedQueries === null) {
+            return null;
+        }
+
+        return [$collection, $convertedQueries, $skipAuth];
+    }
+
+    /**
+     * @param  array<Query>  $joins
+     * @return array<string, bool>
+     */
+    private function authorizeJoins(array $joins, PermissionType $forPermission): array
+    {
+        $joinDocumentSecurity = [];
+
+        foreach ($joins as $joinQuery) {
+            $joinCollectionId = $joinQuery->getAttribute();
+            $joinCollection = $this->silent(fn () => $this->getCollection($joinCollectionId));
+
+            if ($joinCollection->isEmpty()) {
+                throw new QueryException("Joined collection '{$joinCollectionId}' not found");
+            }
+
+            if (! $this->authorization->isValid(new Input($forPermission, $joinCollection->getPermissionsByType($forPermission)))) {
+                throw new AuthorizationException("Unauthorized access to joined collection '{$joinCollectionId}'");
+            }
+
+            $enabled = (bool) $joinCollection->getAttribute('documentSecurity', false);
+            foreach ($this->joinDocumentSecurityKeys($joinCollectionId, $joinCollection) as $key) {
+                $joinDocumentSecurity[$key] = $enabled;
+            }
+        }
+
+        return $joinDocumentSecurity;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private function joinDocumentSecurityKeys(string $joinCollectionId, Document $joinCollection): array
+    {
+        $keys = [
+            $joinCollectionId,
+            $joinCollection->getId(),
+            $this->adapter->filter($joinCollectionId),
+            $this->adapter->filter($joinCollection->getId()),
+        ];
+
+        return \array_values(\array_unique(\array_filter(
+            $keys,
+            static fn (string $key): bool => $key !== '',
+        )));
+    }
+
+    /**
+     * @param  array<string, bool>  $joinDocumentSecurity
+     */
+    private function withJoinDocumentSecurity(Document $collection, array $joinDocumentSecurity): Document
+    {
+        if ($joinDocumentSecurity === []) {
+            return $collection;
+        }
+
+        $adapterCollection = clone $collection;
+        $adapterCollection->setAttribute('joinDocumentSecurity', $joinDocumentSecurity);
+
+        return $adapterCollection;
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<string>
+     */
+    private function validateSelections(Document $collection, array $queries): array
+    {
+        if (empty($queries)) {
+            return [];
+        }
+
+        /** @var array<string> $selections */
+        $selections = [];
+        /** @var array<string> $relationshipSelections */
+        $relationshipSelections = [];
+
+        foreach ($queries as $query) {
+            if ($query->getMethod() == Method::Select) {
+                foreach ($query->getValues() as $value) {
+                    if (! \is_string($value)) {
+                        throw new QueryException('Select queries must contain only string attributes.');
+                    }
+
+                    $strVal = $value;
+                    if (\str_contains($strVal, '.')) {
+                        $relationshipSelections[] = $strVal;
+
+                        continue;
+                    }
+                    $selections[] = $strVal;
+                }
+            }
+        }
+
+        // Allow querying internal attributes
+        /** @var array<string> $keys */
+        $keys = \array_map(
+            fn (array $attribute) => $attribute[Document::ID] ?? '',
+            $this->getInternalAttributes()
+        );
+
+        /** @var array<Document> $collAttrs */
+        $collAttrs = $collection->getAttribute('attributes', []);
+        foreach ($collAttrs as $attribute) {
+            if (Attribute::isRelationship($attribute)) {
+                continue;
+            }
+            /** @var string $attrKey */
+            $attrKey = $attribute->getAttribute('key', $attribute->getId());
+            $keys[] = $attrKey;
+        }
+        if ($this->adapter->supports(Capability::DefinedAttributes)) {
+            $invalid = \array_diff($selections, $keys);
+            if (! empty($invalid) && ! \in_array('*', $invalid)) {
+                throw new QueryException('Cannot select attributes: '.\implode(', ', $invalid));
+            }
+        }
+
+        $selections = \array_merge($selections, $relationshipSelections);
+
+        $selections[] = Document::ID;
+        $selections[] = Document::SEQUENCE;
+        $selections[] = Document::COLLECTION;
+        $selections[] = Document::CREATED_AT;
+        $selections[] = Document::UPDATED_AT;
+        $selections[] = Document::PERMISSIONS;
+
+        return \array_values(\array_unique($selections));
+    }
+
+    /**
+     * @param  array<mixed>  $queries
+     *
+     * @throws QueryException
+     */
+    private function checkQueryTypes(array $queries): void
+    {
+        foreach ($queries as $query) {
+            if (! $query instanceof Query) {
+                throw new QueryException('Invalid query type: "'.\gettype($query).'". Expected instances of "'.Query::class.'"');
+            }
+
+            if ($query->isNested()) {
+                $this->checkQueryTypes($query->getValues());
+            }
+        }
+    }
+
+    private function castingBefore(Document $collection, Document $document): Document
+    {
+        if ($this->adapter->hasFeature(Feature\InternalCasting::class)) {
+            return $this->adapter->castingBefore($collection, $document);
+        }
+
+        return $document;
+    }
+
+    private function castingAfter(Document $collection, Document $document): Document
+    {
+        if ($this->adapter->hasFeature(Feature\InternalCasting::class)) {
+            return $this->adapter->castingAfter($collection, $document);
+        }
+
+        return $document;
+    }
+}
diff --git a/src/Database/Traits/Indexes.php b/src/Database/Traits/Indexes.php
new file mode 100644
index 0000000000..cb1dd13762
--- /dev/null
+++ b/src/Database/Traits/Indexes.php
@@ -0,0 +1,434 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Exception;
+use Throwable;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Index as IndexException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
+use Utopia\Database\SetType;
+use Utopia\Database\Validator\Index as IndexValidator;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Provides CRUD operations for collection indexes including creation, renaming, and deletion.
+ */
+trait Indexes
+{
+    /**
+     * Create Index
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  Index  $index  The index definition to create
+     * @return bool True if the index was created successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws StructureException
+     * @throws Exception
+     */
+    public function createIndex(string $collection, Index $index): bool
+    {
+        $id = $index->key;
+        $type = $index->type;
+        $attributes = $index->attributes;
+        $lengths = $index->lengths;
+        $orders = $index->orders;
+        $ttl = $index->ttl;
+
+        if (empty($attributes)) {
+            throw new DatabaseException('Missing attributes');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        // index IDs are case-insensitive
+        $indexes = $collection->getAttribute('indexes', []);
+
+        /** @var array<Document> $indexes */
+        foreach ($indexes as $existingIndex) {
+            if (\strtolower($existingIndex->getId()) === \strtolower($id)) {
+                throw new DuplicateException('Index already exists');
+            }
+        }
+
+        if ($this->adapter->getCountOfIndexes($collection) >= $this->adapter->getLimitForIndexes()) {
+            throw new LimitException('Index limit reached. Cannot create new index.');
+        }
+
+        /** @var array<Attribute> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $indexAttributesWithTypes = [];
+        foreach ($attributes as $i => $attr) {
+            // Support nested paths on object attributes using dot notation:
+            // attribute.key.nestedKey -> base attribute "attribute"
+            $baseAttr = $attr;
+            if (\str_contains($attr, '.')) {
+                $baseAttr = \explode('.', $attr, 2)[0];
+            }
+
+            foreach ($collectionAttributes as $typedAttr) {
+                if ($typedAttr->key === $baseAttr) {
+
+                    $indexAttributesWithTypes[$attr] = $typedAttr->type->value;
+
+                    /**
+                     * mysql does not save length in collection when length = attributes size
+                     */
+                    if ($typedAttr->type === ColumnType::String) {
+                        if (! empty($lengths[$i]) && $lengths[$i] === $typedAttr->size && $this->adapter->getMaxIndexLength() > 0) {
+                            $lengths[$i] = null;
+                        }
+                    }
+
+                    if ($typedAttr->array) {
+                        if ($this->adapter->getMaxIndexLength() > 0) {
+                            $lengths[$i] = self::MAX_ARRAY_INDEX_LENGTH;
+                        }
+                        $orders[$i] = null;
+                    }
+                    break;
+                }
+            }
+        }
+
+        // Update the index model with potentially modified lengths/orders
+        $index = new Index(
+            key: $id,
+            type: $type,
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl
+        );
+
+        if ($this->validate) {
+            /** @var array<Attribute> $collectionAttrsForValidation */
+            $collectionAttrsForValidation = $collection->getAttribute('attributes', []);
+            /** @var array<Index> $collectionIdxsForValidation */
+            $collectionIdxsForValidation = $collection->getAttribute('indexes', []);
+
+            $validator = new IndexValidator(
+                $collectionAttrsForValidation,
+                $collectionIdxsForValidation,
+                $this->adapter->getMaxIndexLength(),
+                $this->adapter->getInternalIndexesKeys(),
+                $this->adapter->supports(Capability::IndexArray),
+                $this->adapter->supports(Capability::SpatialIndexNull),
+                $this->adapter->supports(Capability::SpatialIndexOrder),
+                $this->adapter->supports(Capability::Vectors),
+                $this->adapter->supports(Capability::DefinedAttributes),
+                $this->adapter->supports(Capability::MultipleFulltextIndexes),
+                $this->adapter->supports(Capability::IdenticalIndexes),
+                $this->adapter->supports(Capability::ObjectIndexes),
+                $this->adapter->supports(Capability::TrigramIndex),
+                $this->adapter->hasFeature(Feature\Spatial::class),
+                $this->adapter->supports(Capability::Index),
+                $this->adapter->supports(Capability::UniqueIndex),
+                $this->adapter->supports(Capability::Fulltext),
+                $this->adapter->supports(Capability::TTLIndexes),
+                $this->adapter->supports(Capability::Objects)
+            );
+            if (! $validator->isValid($index)) {
+                throw new IndexException($validator->getDescription());
+            }
+        }
+
+        $created = false;
+
+        try {
+            $created = $this->adapter->createIndex($collection->getId(), $index, $indexAttributesWithTypes);
+
+            if (! $created) {
+                throw new DatabaseException('Failed to create index');
+            }
+        } catch (DuplicateException $e) {
+            // Metadata check (lines above) already verified index is absent
+            // from metadata. A DuplicateException from the adapter means the
+            // index exists only in physical schema — an orphan from a prior
+            // partial failure. Skip creation and proceed to metadata update.
+        }
+
+        $collection->setAttribute('indexes', $index, SetType::Append);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->cleanupIndex($collection->getId(), $id),
+            shouldRollback: $created,
+            operationDescription: "index creation '{$id}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        $this->triggerHooks(
+            Event::IndexCreate,
+            $index->toDocument()->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    /**
+     * Rename Index
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $old  Current index ID
+     * @param  string  $new  New index ID
+     * @return bool True if the index was renamed successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws StructureException
+     */
+    public function renameIndex(string $collection, string $old, string $new): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        $index = \in_array($old, \array_map(fn ($idx) => $idx[Document::ID], $indexes));
+
+        if ($index === false) {
+            throw new NotFoundException('Index not found');
+        }
+
+        $indexNewExists = \in_array($new, \array_map(fn ($idx) => $idx[Document::ID], $indexes));
+
+        if ($indexNewExists !== false) {
+            throw new DuplicateException('Index name already used');
+        }
+
+        /** @var Document|null $indexNew */
+        $indexNew = null;
+        foreach ($indexes as $key => $value) {
+            if ($value->getId() === $old) {
+                $value->setAttribute('key', $new);
+                $value->setAttribute(Document::ID, $new);
+                $indexNew = $value;
+                $indexes[$key] = $value;
+                break;
+            }
+        }
+
+        if ($indexNew === null) {
+            throw new NotFoundException('Index not found');
+        }
+
+        $collection->setAttribute('indexes', $indexes);
+
+        $renamed = false;
+        try {
+            $renamed = $this->adapter->renameIndex($collection->getId(), $old, $new);
+            if (! $renamed) {
+                throw new DatabaseException('Failed to rename index');
+            }
+        } catch (Throwable $e) {
+            // Check if the rename already happened in schema (orphan from prior
+            // partial failure where rename succeeded but metadata update and
+            // rollback both failed). Verify by attempting a reverse rename — if
+            // $new exists in schema, the reverse succeeds confirming a prior rename.
+            try {
+                $this->adapter->renameIndex($collection->getId(), $new, $old);
+                // Reverse succeeded — index was at $new. Re-rename to complete.
+                $renamed = $this->adapter->renameIndex($collection->getId(), $old, $new);
+            } catch (Throwable) {
+                // Reverse also failed — genuine error
+                throw new DatabaseException("Failed to rename index '{$old}' to '{$new}': ".$e->getMessage(), previous: $e);
+            }
+        }
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->adapter->renameIndex($collection->getId(), $new, $old),
+            shouldRollback: $renamed,
+            operationDescription: "index rename '{$old}' to '{$new}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        $this->triggerHooks(
+            Event::IndexRename,
+            (clone $indexNew)->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    /**
+     * Delete Index
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The index identifier to delete
+     * @return bool True if the index was deleted successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws StructureException
+     */
+    public function deleteIndex(string $collection, string $id): bool
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        /** @var array<Index> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        /** @var Index|null $indexDeleted */
+        $indexDeleted = null;
+        foreach ($indexes as $key => $value) {
+            if ($value->getId() === $id) {
+                $indexDeleted = $value;
+                unset($indexes[$key]);
+            }
+        }
+
+        if (\is_null($indexDeleted)) {
+            throw new NotFoundException('Index not found');
+        }
+
+        $shouldRollback = false;
+        $deleted = false;
+        try {
+            $deleted = $this->adapter->deleteIndex($collection->getId(), $id);
+
+            if (! $deleted) {
+                throw new DatabaseException('Failed to delete index');
+            }
+            $shouldRollback = true;
+        } catch (NotFoundException) {
+            // Index already absent from schema; treat as deleted
+            $deleted = true;
+        }
+
+        $collection->setAttribute('indexes', \array_values($indexes));
+
+        // Build indexAttributeTypes from collection attributes for rollback
+        /** @var array<Attribute> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $typedDeletedIndex = $indexDeleted;
+        /** @var array<string, string> $indexAttributeTypes */
+        $indexAttributeTypes = [];
+        foreach ($typedDeletedIndex->attributes as $attr) {
+            $baseAttr = \str_contains($attr, '.') ? \explode('.', $attr, 2)[0] : $attr;
+            foreach ($collectionAttributes as $collectionAttribute) {
+                if ($collectionAttribute->key === $baseAttr) {
+                    $indexAttributeTypes[$attr] = $collectionAttribute->type->value;
+                    break;
+                }
+            }
+        }
+
+        $rollbackIndex = new Index(
+            key: $id,
+            type: $typedDeletedIndex->type,
+            attributes: $typedDeletedIndex->attributes,
+            lengths: $typedDeletedIndex->lengths,
+            orders: $typedDeletedIndex->orders,
+            ttl: $typedDeletedIndex->ttl
+        );
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->adapter->createIndex(
+                $collection->getId(),
+                $rollbackIndex,
+                $indexAttributeTypes,
+            ),
+            shouldRollback: $shouldRollback,
+            operationDescription: "index deletion '{$id}'",
+            silentRollback: true
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        $this->triggerHooks(
+            Event::IndexDelete,
+            $indexDeleted->toDocument()->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return $deleted;
+    }
+
+    /**
+     * Update index metadata. Utility method for update index methods.
+     *
+     * @param  callable(Index, Document, int|string): void  $updateCallback
+     *
+     * @throws ConflictException
+     * @throws DatabaseException
+     */
+    protected function updateIndexMeta(string $collection, string $id, callable $updateCallback): Index
+    {
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collection->getId() === self::METADATA) {
+            throw new DatabaseException('Cannot update metadata indexes');
+        }
+
+        /** @var array<Index> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+        $index = \array_search($id, \array_map(fn (Index $idx) => $idx->key, $indexes), true);
+
+        if ($index === false) {
+            throw new NotFoundException('Index not found');
+        }
+
+        $indexModel = $indexes[$index];
+
+        $updateCallback($indexModel, $collection, $index);
+        $indexes[$index] = $indexModel;
+
+        $collection->setAttribute('indexes', $indexes);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: null,
+            shouldRollback: false,
+            operationDescription: "index metadata update '{$id}'"
+        );
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+
+        return $indexModel;
+    }
+
+    /**
+     * Cleanup an index that was created in the adapter but whose metadata
+     * persistence failed.
+     *
+     * @param  string  $collectionId  The collection ID
+     * @param  string  $indexId  The index ID
+     * @param  int  $maxAttempts  Maximum retry attempts
+     *
+     * @throws DatabaseException If cleanup fails after all retries
+     */
+    private function cleanupIndex(
+        string $collectionId,
+        string $indexId,
+        int $maxAttempts = 3
+    ): void {
+        $this->cleanup(
+            fn () => $this->adapter->deleteIndex($collectionId, $indexId),
+            'index',
+            $indexId,
+            $maxAttempts
+        );
+    }
+}
diff --git a/src/Database/Traits/Relationships.php b/src/Database/Traits/Relationships.php
new file mode 100644
index 0000000000..a535a3fb9a
--- /dev/null
+++ b/src/Database/Traits/Relationships.php
@@ -0,0 +1,973 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Throwable;
+use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Relationship as RelationshipException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Database\SetType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Provides relationship attribute management including creation, update, deletion, and traversal control.
+ */
+trait Relationships
+{
+    /**
+     * Skip relationships for all the calls inside the callback
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     */
+    public function skipRelationships(callable $callback): mixed
+    {
+        if ($this->relationshipHook === null) {
+            return $callback();
+        }
+
+        $previous = $this->relationshipHook->isEnabled();
+        $this->relationshipHook->setEnabled(false);
+
+        try {
+            return $callback();
+        } finally {
+            $this->relationshipHook->setEnabled($previous);
+        }
+    }
+
+    /**
+     * Skip relationship existence checks for all calls inside the callback.
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     */
+    public function skipRelationshipsExistCheck(callable $callback): mixed
+    {
+        if ($this->relationshipHook === null) {
+            return $callback();
+        }
+
+        $previous = $this->relationshipHook->shouldCheckExist();
+        $this->relationshipHook->setCheckExist(false);
+
+        try {
+            return $callback();
+        } finally {
+            $this->relationshipHook->setCheckExist($previous);
+        }
+    }
+
+    /**
+     * Cleanup a relationship on failure
+     *
+     * @param  string  $collectionId  The collection ID
+     * @param  string  $relatedCollectionId  The related collection ID
+     * @param  RelationType  $type  The relationship type
+     * @param  bool  $twoWay  Whether the relationship is two-way
+     * @param  string  $key  The relationship key
+     * @param  string  $twoWayKey  The two-way relationship key
+     * @param  RelationSide  $side  The relationship side
+     * @param  int  $maxAttempts  Maximum retry attempts
+     *
+     * @throws DatabaseException If cleanup fails after all retries
+     */
+    private function cleanupRelationship(
+        string $collectionId,
+        string $relatedCollectionId,
+        RelationType $type,
+        bool $twoWay,
+        string $key,
+        string $twoWayKey,
+        RelationSide $side = RelationSide::Parent,
+        int $maxAttempts = 3
+    ): void {
+        $adapter = $this->adapter;
+        if (! $adapter->hasFeature(Feature\Relationships::class)) {
+            throw new DatabaseException('Adapter does not support relationships');
+        }
+
+        $relationshipModel = new Relationship(
+            collection: $collectionId,
+            relatedCollection: $relatedCollectionId,
+            type: $type,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            side: $side,
+        );
+        $this->cleanup(
+            fn () => $adapter->deleteRelationship($relationshipModel),
+            'relationship',
+            $key,
+            $maxAttempts
+        );
+    }
+
+    /**
+     * Create a relationship attribute between two collections.
+     *
+     * @param  Relationship  $relationship  The relationship definition
+     * @return bool True if the relationship was created successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws StructureException
+     */
+    public function createRelationship(
+        Relationship $relationship
+    ): bool {
+        if (! $this->adapter->hasFeature(Feature\Relationships::class)) {
+            throw new DatabaseException('Adapter does not support relationships');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($relationship->collection));
+        $relatedCollection = $this->silent(fn () => $this->getCollection($relationship->relatedCollection));
+
+        /** @var Document $collection */
+        /** @var Document $relatedCollection */
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+        if ($relatedCollection->isEmpty()) {
+            throw new NotFoundException('Related collection not found');
+        }
+
+        $type = $relationship->type;
+        $twoWay = $relationship->twoWay;
+        $id = ! empty($relationship->key) ? $relationship->key : $this->adapter->filter($relatedCollection->getId());
+        $twoWayKey = ! empty($relationship->twoWayKey) ? $relationship->twoWayKey : $this->adapter->filter($collection->getId());
+        $onDelete = $relationship->onDelete;
+
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        foreach ($attributes as $attribute) {
+            if (\strtolower($attribute->key) === \strtolower($id)) {
+                throw new DuplicateException('Attribute already exists');
+            }
+
+            if ($attribute->type === ColumnType::Relationship) {
+                $existingRel = Relationship::fromArray(['collection' => $collection->getId()] + $attribute->getArrayCopy());
+                if (
+                    \strtolower($existingRel->twoWayKey) === \strtolower($twoWayKey)
+                    && $existingRel->relatedCollection === $relatedCollection->getId()
+                ) {
+                    throw new DuplicateException('Related attribute already exists');
+                }
+            }
+        }
+
+        $relationship = Attribute::relationship(
+            key: $id,
+            options: [
+                'relatedCollection' => $relatedCollection->getId(),
+                'relationType' => $type->value,
+                'twoWay' => $twoWay,
+                'twoWayKey' => $twoWayKey,
+                'onDelete' => $onDelete->value,
+                'side' => RelationSide::Parent->value,
+            ],
+        );
+
+        $twoWayRelationship = Attribute::relationship(
+            key: $twoWayKey,
+            options: [
+                'relatedCollection' => $collection->getId(),
+                'relationType' => $type->value,
+                'twoWay' => $twoWay,
+                'twoWayKey' => $id,
+                'onDelete' => $onDelete->value,
+                'side' => RelationSide::Child->value,
+            ],
+        );
+
+        $this->checkAttribute($collection, $relationship);
+        $this->checkAttribute($relatedCollection, $twoWayRelationship);
+
+        /** @var ?string $junctionCollection */
+        $junctionCollection = null;
+        if ($type === RelationType::ManyToMany) {
+            $junctionCollection = '_'.$collection->getSequence().'_'.$relatedCollection->getSequence();
+            $junctionAttributes = [
+                Attribute::string(key: $id, required: true),
+                Attribute::string(key: $twoWayKey, required: true),
+            ];
+            $junctionIndexes = [
+                Index::key(key: '_index_'.$id, attributes: [$id]),
+                Index::key(key: '_index_'.$twoWayKey, attributes: [$twoWayKey]),
+            ];
+            try {
+                $this->silent(fn () => $this->createCollection(new Collection(id: $junctionCollection, attributes: $junctionAttributes, indexes: $junctionIndexes)));
+            } catch (DuplicateException) {
+                // Junction metadata already exists from a prior partial failure.
+                // Ensure the physical schema also exists.
+                try {
+                    $this->adapter->createCollection($junctionCollection, $junctionAttributes, $junctionIndexes);
+                } catch (DuplicateException) {
+                    // Schema already exists — ignore
+                }
+            }
+        }
+
+        $created = false;
+
+        $adapterRelationship = new Relationship(
+            collection: $collection->getId(),
+            relatedCollection: $relatedCollection->getId(),
+            type: $type,
+            twoWay: $twoWay,
+            key: $id,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete,
+            side: RelationSide::Parent,
+        );
+
+        try {
+            $created = $this->adapter->createRelationship($adapterRelationship);
+
+            if (! $created) {
+                if ($junctionCollection !== null) {
+                    try {
+                        $this->silent(fn () => $this->cleanupCollection($junctionCollection));
+                    } catch (Throwable $e) {
+                        Console::error("Failed to cleanup junction collection '{$junctionCollection}': ".$e->getMessage());
+                    }
+                }
+                throw new DatabaseException('Failed to create relationship');
+            }
+        } catch (DuplicateException) {
+            // Metadata checks (above) already verified relationship is absent
+            // from metadata. A DuplicateException from the adapter means the
+            // relationship exists only in physical schema — an orphan from a
+            // prior partial failure. Skip creation and proceed to metadata update.
+        }
+
+        $collection->setAttribute('attributes', $relationship, SetType::Append);
+        $relatedCollection->setAttribute('attributes', $twoWayRelationship, SetType::Append);
+
+        $this->silent(function () use ($collection, $relatedCollection, $type, $twoWay, $id, $twoWayKey, $junctionCollection, $created) {
+            $indexesCreated = [];
+            try {
+                $this->skipValidation(function () use ($collection, $relatedCollection) {
+                    $this->withRetries(function () use ($collection, $relatedCollection) {
+                        $this->withTransaction(function () use ($collection, $relatedCollection) {
+                            $this->updateDocument(self::METADATA, $collection->getId(), $collection);
+                            $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
+                        });
+                    });
+                });
+            } catch (Throwable $e) {
+                $this->rollbackAttributeMetadata($collection, [$id]);
+                $this->rollbackAttributeMetadata($relatedCollection, [$twoWayKey]);
+
+                if ($created) {
+                    try {
+                        $this->cleanupRelationship(
+                            $collection->getId(),
+                            $relatedCollection->getId(),
+                            $type,
+                            $twoWay,
+                            $id,
+                            $twoWayKey,
+                            RelationSide::Parent
+                        );
+                    } catch (Throwable $e) {
+                        Console::error("Failed to cleanup relationship '{$id}': ".$e->getMessage());
+                    }
+
+                    if ($junctionCollection !== null) {
+                        try {
+                            $this->cleanupCollection($junctionCollection);
+                        } catch (Throwable $e) {
+                            Console::error("Failed to cleanup junction collection '{$junctionCollection}': ".$e->getMessage());
+                        }
+                    }
+                }
+
+                throw new DatabaseException('Failed to create relationship: '.$e->getMessage());
+            }
+
+            $indexKey = '_index_'.$id;
+            $twoWayIndexKey = '_index_'.$twoWayKey;
+            $indexesCreated = [];
+
+            try {
+                switch ($type) {
+                    case RelationType::OneToOne:
+                        $this->createIndex($collection->getId(), Index::unique(key: $indexKey, attributes: [$id]));
+                        $indexesCreated[] = ['collection' => $collection->getId(), 'index' => $indexKey];
+                        if ($twoWay) {
+                            $this->createIndex($relatedCollection->getId(), Index::unique(key: $twoWayIndexKey, attributes: [$twoWayKey]));
+                            $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
+                        }
+                        break;
+                    case RelationType::OneToMany:
+                        $this->createIndex($relatedCollection->getId(), Index::key(key: $twoWayIndexKey, attributes: [$twoWayKey]));
+                        $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
+                        break;
+                    case RelationType::ManyToOne:
+                        $this->createIndex($collection->getId(), Index::key(key: $indexKey, attributes: [$id]));
+                        $indexesCreated[] = ['collection' => $collection->getId(), 'index' => $indexKey];
+                        break;
+                    case RelationType::ManyToMany:
+                        // Indexes created on junction collection creation
+                        break;
+                    default:
+                        throw new RelationshipException('Invalid relationship type.');
+                }
+            } catch (Throwable $e) {
+                foreach ($indexesCreated as $indexInfo) {
+                    try {
+                        $this->deleteIndex($indexInfo['collection'], $indexInfo['index']);
+                    } catch (Throwable $cleanupError) {
+                        Console::error("Failed to cleanup index '{$indexInfo['index']}': ".$cleanupError->getMessage());
+                    }
+                }
+
+                try {
+                    $this->skipValidation(fn () => $this->withTransaction(function () use ($collection, $relatedCollection, $id, $twoWayKey) {
+                        /** @var array<Attribute> $attributes */
+                        $attributes = $collection->getAttribute('attributes', []);
+                        $collection->setAttribute('attributes', array_filter($attributes, fn (Attribute $attr) => $attr->getId() !== $id));
+                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
+
+                        /** @var array<Attribute> $relatedAttributes */
+                        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
+                        $relatedCollection->setAttribute('attributes', array_filter($relatedAttributes, fn (Attribute $attr) => $attr->getId() !== $twoWayKey));
+                        $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
+                    }));
+                } catch (Throwable $cleanupError) {
+                    Console::error("Failed to cleanup metadata for relationship '{$id}': ".$cleanupError->getMessage());
+                }
+
+                // Cleanup relationship
+                try {
+                    $this->cleanupRelationship(
+                        $collection->getId(),
+                        $relatedCollection->getId(),
+                        $type,
+                        $twoWay,
+                        $id,
+                        $twoWayKey,
+                        RelationSide::Parent
+                    );
+                } catch (Throwable $cleanupError) {
+                    Console::error("Failed to cleanup relationship '{$id}': ".$cleanupError->getMessage());
+                }
+
+                if ($junctionCollection !== null) {
+                    try {
+                        $this->cleanupCollection($junctionCollection);
+                    } catch (Throwable $cleanupError) {
+                        Console::error("Failed to cleanup junction collection '{$junctionCollection}': ".$cleanupError->getMessage());
+                    }
+                }
+
+                throw new DatabaseException('Failed to create relationship indexes: '.$e->getMessage());
+            }
+        });
+
+        $this->triggerHooks(
+            Event::AttributeCreate,
+            (clone $relationship)->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    /**
+     * Update a relationship attribute's keys, two-way status, or on-delete behavior.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The relationship attribute identifier
+     * @param  string|null  $newKey  New key for the relationship attribute
+     * @param  string|null  $newTwoWayKey  New key for the two-way relationship attribute
+     * @param  bool|null  $twoWay  Whether the relationship should be two-way
+     * @param  ForeignKeyAction|null  $onDelete  Action to take on related document deletion
+     * @return bool True if the relationship was updated successfully
+     *
+     * @throws ConflictException
+     * @throws DatabaseException
+     */
+    public function updateRelationship(
+        string $collection,
+        string $id,
+        ?string $newKey = null,
+        ?string $newTwoWayKey = null,
+        ?bool $twoWay = null,
+        ?ForeignKeyAction $onDelete = null
+    ): bool {
+        if (! $this->adapter->hasFeature(Feature\Relationships::class)) {
+            throw new DatabaseException('Adapter does not support relationships');
+        }
+
+        if (
+            $newKey === null
+            && $newTwoWayKey === null
+            && $twoWay === null
+            && $onDelete === null
+        ) {
+            return true;
+        }
+
+        $collection = $this->getCollection($collection);
+        /** @var array<Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        if (
+            $newKey !== null
+            && \in_array($newKey, \array_map(fn (Attribute $attribute) => $attribute->key, $attributes), true)
+        ) {
+            throw new DuplicateException('Relationship already exists');
+        }
+
+        $attributeIndex = array_search($id, array_map(fn (Attribute $attribute) => $attribute->key, $attributes), true);
+
+        if ($attributeIndex === false) {
+            throw new NotFoundException('Relationship not found');
+        }
+
+        $attribute = $attributes[$attributeIndex];
+        $oldRel = Relationship::fromArray(['collection' => $collection->getId()] + $attribute->getArrayCopy());
+
+        $relatedCollectionId = $oldRel->relatedCollection;
+        $relatedCollection = $this->getCollection($relatedCollectionId);
+
+        // Determine if we need to alter the database (rename columns/indexes)
+        $oldTwoWayKey = $oldRel->twoWayKey;
+        $altering = ($newKey !== null && $newKey !== $id)
+            || ($newTwoWayKey !== null && $newTwoWayKey !== $oldTwoWayKey);
+
+        // Validate new keys don't already exist
+        /** @var array<Attribute> $relatedAttrs */
+        $relatedAttrs = $relatedCollection->getAttribute('attributes', []);
+        if (
+            $newTwoWayKey !== null
+            && \in_array($newTwoWayKey, \array_map(fn (Attribute $attribute) => $attribute->key, $relatedAttrs), true)
+        ) {
+            throw new DuplicateException('Related attribute already exists');
+        }
+
+        $actualNewKey = $newKey ?? $id;
+        $actualNewTwoWayKey = $newTwoWayKey ?? $oldTwoWayKey;
+        $actualTwoWay = $twoWay ?? $oldRel->twoWay;
+        $actualOnDelete = $onDelete ?? $oldRel->onDelete;
+
+        $adapterUpdated = false;
+        if ($altering) {
+            try {
+                $updateRelModel = new Relationship(
+                    collection: $collection->getId(),
+                    relatedCollection: $relatedCollection->getId(),
+                    type: $oldRel->type,
+                    twoWay: $actualTwoWay,
+                    key: $id,
+                    twoWayKey: $oldTwoWayKey,
+                    onDelete: $actualOnDelete,
+                    side: $oldRel->side,
+                );
+                $adapterUpdated = $this->adapter->updateRelationship(
+                    $updateRelModel,
+                    $actualNewKey,
+                    $actualNewTwoWayKey
+                );
+
+                if (! $adapterUpdated) {
+                    throw new DatabaseException('Failed to update relationship');
+                }
+            } catch (Throwable $e) {
+                // Check if the rename already happened in schema (orphan from prior
+                // partial failure where adapter succeeded but metadata+rollback failed).
+                // If the new column names already exist, the prior rename completed.
+                if ($this->adapter->hasFeature(Feature\SchemaAttributes::class)) {
+                    $schemaAttributes = $this->getSchemaAttributes($collection->getId());
+                    $filteredNewKey = $this->adapter->filter($actualNewKey);
+                    $newKeyExists = false;
+                    foreach ($schemaAttributes as $schemaAttr) {
+                        if (\strtolower($schemaAttr->getId()) === \strtolower($filteredNewKey)) {
+                            $newKeyExists = true;
+                            break;
+                        }
+                    }
+                    if ($newKeyExists) {
+                        $adapterUpdated = true;
+                    } else {
+                        throw new DatabaseException("Failed to update relationship '{$id}': ".$e->getMessage(), previous: $e);
+                    }
+                } else {
+                    throw new DatabaseException("Failed to update relationship '{$id}': ".$e->getMessage(), previous: $e);
+                }
+            }
+        }
+
+        try {
+            $this->updateAttributeMeta($collection->getId(), $id, function ($attribute) use ($actualNewKey, $actualNewTwoWayKey, $actualTwoWay, $actualOnDelete, $relatedCollection, $oldRel) {
+                $attribute->setAttribute(Document::ID, $actualNewKey);
+                $attribute->setAttribute('key', $actualNewKey);
+                $attribute->setAttribute('options', [
+                    'relatedCollection' => $relatedCollection->getId(),
+                    'relationType' => $oldRel->type,
+                    'twoWay' => $actualTwoWay,
+                    'twoWayKey' => $actualNewTwoWayKey,
+                    'onDelete' => $actualOnDelete,
+                    'side' => $oldRel->side,
+                ]);
+            });
+
+            $this->updateAttributeMeta($relatedCollection->getId(), $oldTwoWayKey, function (Document $twoWayAttribute) use ($actualNewKey, $actualNewTwoWayKey, $actualTwoWay, $actualOnDelete) {
+                /** @var array<string, mixed> $options */
+                $options = $twoWayAttribute->getAttribute('options', []);
+                $options['twoWayKey'] = $actualNewKey;
+                $options['twoWay'] = $actualTwoWay;
+                $options['onDelete'] = $actualOnDelete;
+
+                $twoWayAttribute->setAttribute(Document::ID, $actualNewTwoWayKey);
+                $twoWayAttribute->setAttribute('key', $actualNewTwoWayKey);
+                $twoWayAttribute->setAttribute('options', $options);
+            });
+
+            if ($oldRel->type === RelationType::ManyToMany) {
+                $junction = $this->getJunctionCollection($collection, $relatedCollection, $oldRel->side);
+
+                $this->updateAttributeMeta($junction, $id, function ($junctionAttribute) use ($actualNewKey) {
+                    $junctionAttribute->setAttribute(Document::ID, $actualNewKey);
+                    $junctionAttribute->setAttribute('key', $actualNewKey);
+                });
+                $this->updateAttributeMeta($junction, $oldTwoWayKey, function ($junctionAttribute) use ($actualNewTwoWayKey) {
+                    $junctionAttribute->setAttribute(Document::ID, $actualNewTwoWayKey);
+                    $junctionAttribute->setAttribute('key', $actualNewTwoWayKey);
+                });
+
+                $this->withRetries(fn () => $this->purgeCachedCollection($junction));
+            }
+        } catch (Throwable $e) {
+            if ($adapterUpdated) {
+                try {
+                    $reverseRelModel = new Relationship(
+                        collection: $collection->getId(),
+                        relatedCollection: $relatedCollection->getId(),
+                        type: $oldRel->type,
+                        twoWay: $actualTwoWay,
+                        key: $actualNewKey,
+                        twoWayKey: $actualNewTwoWayKey,
+                        onDelete: $actualOnDelete,
+                        side: $oldRel->side,
+                    );
+                    $this->adapter->updateRelationship(
+                        $reverseRelModel,
+                        $id,
+                        $oldTwoWayKey
+                    );
+                } catch (Throwable $e) {
+                    // Ignore
+                }
+            }
+            throw $e;
+        }
+
+        // Update Indexes — wrapped in rollback for consistency with metadata
+        $renameIndex = function (string $collection, string $key, string $newKey) {
+            $this->updateIndexMeta(
+                $collection,
+                '_index_'.$key,
+                function ($index) use ($newKey) {
+                    $index->setAttribute('attributes', [$newKey]);
+                }
+            );
+            $this->silent(
+                fn () => $this->renameIndex($collection, '_index_'.$key, '_index_'.$newKey)
+            );
+        };
+
+        $indexRenamesCompleted = [];
+
+        try {
+            switch ($oldRel->type) {
+                case RelationType::OneToOne:
+                    if ($id !== $actualNewKey) {
+                        $renameIndex($collection->getId(), $id, $actualNewKey);
+                        $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
+                    }
+                    if ($actualTwoWay && $oldTwoWayKey !== $actualNewTwoWayKey) {
+                        $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
+                        $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
+                    }
+                    break;
+                case RelationType::OneToMany:
+                    if ($oldRel->side === RelationSide::Parent) {
+                        if ($oldTwoWayKey !== $actualNewTwoWayKey) {
+                            $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
+                            $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
+                        }
+                    } else {
+                        if ($id !== $actualNewKey) {
+                            $renameIndex($collection->getId(), $id, $actualNewKey);
+                            $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
+                        }
+                    }
+                    break;
+                case RelationType::ManyToOne:
+                    if ($oldRel->side === RelationSide::Parent) {
+                        if ($id !== $actualNewKey) {
+                            $renameIndex($collection->getId(), $id, $actualNewKey);
+                            $indexRenamesCompleted[] = [$collection->getId(), $actualNewKey, $id];
+                        }
+                    } else {
+                        if ($oldTwoWayKey !== $actualNewTwoWayKey) {
+                            $renameIndex($relatedCollection->getId(), $oldTwoWayKey, $actualNewTwoWayKey);
+                            $indexRenamesCompleted[] = [$relatedCollection->getId(), $actualNewTwoWayKey, $oldTwoWayKey];
+                        }
+                    }
+                    break;
+                case RelationType::ManyToMany:
+                    $junction = $this->getJunctionCollection($collection, $relatedCollection, $oldRel->side);
+
+                    if ($id !== $actualNewKey) {
+                        $renameIndex($junction, $id, $actualNewKey);
+                        $indexRenamesCompleted[] = [$junction, $actualNewKey, $id];
+                    }
+                    if ($oldTwoWayKey !== $actualNewTwoWayKey) {
+                        $renameIndex($junction, $oldTwoWayKey, $actualNewTwoWayKey);
+                        $indexRenamesCompleted[] = [$junction, $actualNewTwoWayKey, $oldTwoWayKey];
+                    }
+                    break;
+                default:
+                    throw new RelationshipException('Invalid relationship type.');
+            }
+        } catch (Throwable $e) {
+            // Reverse completed index renames
+            foreach (\array_reverse($indexRenamesCompleted) as [$coll, $from, $to]) {
+                try {
+                    $renameIndex($coll, $from, $to);
+                } catch (Throwable) {
+                    // Best effort
+                }
+            }
+
+            // Reverse attribute metadata
+            try {
+                $this->updateAttributeMeta($collection->getId(), $actualNewKey, function ($attribute) use ($id, $oldRel) {
+                    $attribute->setAttribute(Document::ID, $id);
+                    $attribute->setAttribute('key', $id);
+                    $attribute->setAttribute('options', $oldRel->toDocument()->getArrayCopy());
+                });
+            } catch (Throwable) {
+                // Best effort
+            }
+
+            try {
+                $this->updateAttributeMeta($relatedCollection->getId(), $actualNewTwoWayKey, function (Document $twoWayAttribute) use ($oldTwoWayKey, $id, $oldRel) {
+                    /** @var array<string, mixed> $options */
+                    $options = $twoWayAttribute->getAttribute('options', []);
+                    $options['twoWayKey'] = $id;
+                    $options['twoWay'] = $oldRel->twoWay;
+                    $options['onDelete'] = $oldRel->onDelete;
+                    $twoWayAttribute->setAttribute(Document::ID, $oldTwoWayKey);
+                    $twoWayAttribute->setAttribute('key', $oldTwoWayKey);
+                    $twoWayAttribute->setAttribute('options', $options);
+                });
+            } catch (Throwable) {
+                // Best effort
+            }
+
+            if ($oldRel->type === RelationType::ManyToMany) {
+                $junctionId = $this->getJunctionCollection($collection, $relatedCollection, $oldRel->side);
+                try {
+                    $this->updateAttributeMeta($junctionId, $actualNewKey, function ($attr) use ($id) {
+                        $attr->setAttribute(Document::ID, $id);
+                        $attr->setAttribute('key', $id);
+                    });
+                } catch (Throwable) {
+                    // Best effort
+                }
+                try {
+                    $this->updateAttributeMeta($junctionId, $actualNewTwoWayKey, function ($attr) use ($oldTwoWayKey) {
+                        $attr->setAttribute(Document::ID, $oldTwoWayKey);
+                        $attr->setAttribute('key', $oldTwoWayKey);
+                    });
+                } catch (Throwable) {
+                    // Best effort
+                }
+            }
+
+            // Reverse adapter update
+            if ($adapterUpdated && $this->adapter->hasFeature(Feature\Relationships::class)) {
+                try {
+                    $reverseRelModel2 = new Relationship(
+                        collection: $collection->getId(),
+                        relatedCollection: $relatedCollection->getId(),
+                        type: $oldRel->type,
+                        twoWay: $oldRel->twoWay,
+                        key: $actualNewKey,
+                        twoWayKey: $actualNewTwoWayKey,
+                        onDelete: $oldRel->onDelete,
+                        side: $oldRel->side,
+                    );
+                    $this->adapter->updateRelationship(
+                        $reverseRelModel2,
+                        $id,
+                        $oldTwoWayKey
+                    );
+                } catch (Throwable) {
+                    // Best effort
+                }
+            }
+
+            throw new DatabaseException("Failed to update relationship indexes for '{$id}': ".$e->getMessage(), previous: $e);
+        }
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+        $this->withRetries(fn () => $this->purgeCachedCollection($relatedCollection->getId()));
+
+        return true;
+    }
+
+    /**
+     * Delete a relationship attribute and its inverse from both collections.
+     *
+     * @param  string  $collection  The collection identifier
+     * @param  string  $id  The relationship attribute identifier
+     * @return bool True if the relationship was deleted successfully
+     *
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws DatabaseException
+     * @throws StructureException
+     */
+    public function deleteRelationship(string $collection, string $id): bool
+    {
+        if (! $this->adapter->hasFeature(Feature\Relationships::class)) {
+            throw new DatabaseException('Adapter does not support relationships');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        /** @var array<int|string, Attribute> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        $relationship = null;
+
+        foreach ($attributes as $name => $attribute) {
+            if ($attribute->key === $id) {
+                $relationship = $attribute;
+                unset($attributes[$name]);
+                break;
+            }
+        }
+
+        if ($relationship === null) {
+            throw new NotFoundException('Relationship not found');
+        }
+
+        $collection->setAttribute('attributes', \array_values($attributes));
+
+        $rel = Relationship::fromArray(['collection' => $collection->getId()] + $relationship->getArrayCopy());
+
+        $relatedCollection = $this->silent(fn () => $this->getCollection($rel->relatedCollection));
+        /** @var array<int|string, Attribute> $relatedAttributes */
+        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
+
+        foreach ($relatedAttributes as $name => $attribute) {
+            if ($attribute->key === $rel->twoWayKey) {
+                unset($relatedAttributes[$name]);
+                break;
+            }
+        }
+
+        $relatedCollection->setAttribute('attributes', \array_values($relatedAttributes));
+
+        $collectionAttributes = $collection->getAttribute('attributes');
+        $relatedCollectionAttributes = $relatedCollection->getAttribute('attributes');
+
+        // Delete indexes BEFORE dropping columns to avoid referencing non-existent columns
+        // Track deleted indexes for rollback
+        $deletedIndexes = [];
+        $deletedJunction = null;
+
+        $this->silent(function () use ($collection, $relatedCollection, $rel, $id, &$deletedIndexes, &$deletedJunction) {
+            $indexKey = '_index_'.$id;
+            $twoWayIndexKey = '_index_'.$rel->twoWayKey;
+
+            switch ($rel->type) {
+                case RelationType::OneToOne:
+                    if ($rel->side === RelationSide::Parent) {
+                        $this->deleteIndex($collection->getId(), $indexKey);
+                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => IndexType::Unique, 'attributes' => [$id]];
+                        if ($rel->twoWay) {
+                            $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                            $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => IndexType::Unique, 'attributes' => [$rel->twoWayKey]];
+                        }
+                    }
+                    if ($rel->side === RelationSide::Child) {
+                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => IndexType::Unique, 'attributes' => [$rel->twoWayKey]];
+                        if ($rel->twoWay) {
+                            $this->deleteIndex($collection->getId(), $indexKey);
+                            $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => IndexType::Unique, 'attributes' => [$id]];
+                        }
+                    }
+                    break;
+                case RelationType::OneToMany:
+                    if ($rel->side === RelationSide::Parent) {
+                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => IndexType::Key, 'attributes' => [$rel->twoWayKey]];
+                    } else {
+                        $this->deleteIndex($collection->getId(), $indexKey);
+                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => IndexType::Key, 'attributes' => [$id]];
+                    }
+                    break;
+                case RelationType::ManyToOne:
+                    if ($rel->side === RelationSide::Parent) {
+                        $this->deleteIndex($collection->getId(), $indexKey);
+                        $deletedIndexes[] = ['collection' => $collection->getId(), 'key' => $indexKey, 'type' => IndexType::Key, 'attributes' => [$id]];
+                    } else {
+                        $this->deleteIndex($relatedCollection->getId(), $twoWayIndexKey);
+                        $deletedIndexes[] = ['collection' => $relatedCollection->getId(), 'key' => $twoWayIndexKey, 'type' => IndexType::Key, 'attributes' => [$rel->twoWayKey]];
+                    }
+                    break;
+                case RelationType::ManyToMany:
+                    $junction = $this->getJunctionCollection(
+                        $collection,
+                        $relatedCollection,
+                        $rel->side
+                    );
+
+                    $deletedJunction = $this->silent(fn () => $this->getDocument(self::METADATA, $junction));
+                    $this->deleteDocument(self::METADATA, $junction);
+                    break;
+                default:
+                    throw new RelationshipException('Invalid relationship type.');
+            }
+        });
+
+        $collection = $this->silent(fn () => $this->getCollection($collection->getId()));
+        $relatedCollection = $this->silent(fn () => $this->getCollection($relatedCollection->getId()));
+        $collection->setAttribute('attributes', $collectionAttributes);
+        $relatedCollection->setAttribute('attributes', $relatedCollectionAttributes);
+
+        $deleteRelModel = new Relationship(
+            collection: $collection->getId(),
+            relatedCollection: $relatedCollection->getId(),
+            type: $rel->type,
+            twoWay: $rel->twoWay,
+            key: $id,
+            twoWayKey: $rel->twoWayKey,
+            side: $rel->side,
+        );
+
+        $shouldRollback = false;
+        try {
+            $deleted = $this->adapter->deleteRelationship($deleteRelModel);
+
+            if (! $deleted) {
+                throw new DatabaseException('Failed to delete relationship');
+            }
+            $shouldRollback = true;
+        } catch (NotFoundException) {
+            // Ignore — relationship already absent from schema
+        }
+
+        try {
+            $this->skipValidation(function () use ($collection, $relatedCollection) {
+                $this->withRetries(function () use ($collection, $relatedCollection) {
+                    $this->silent(function () use ($collection, $relatedCollection) {
+                        $this->withTransaction(function () use ($collection, $relatedCollection) {
+                            $this->updateDocument(self::METADATA, $collection->getId(), $collection);
+                            $this->updateDocument(self::METADATA, $relatedCollection->getId(), $relatedCollection);
+                        });
+                    });
+                });
+            });
+        } catch (Throwable $e) {
+            if ($shouldRollback) {
+                // Recreate relationship columns
+                try {
+                    $recreateRelModel = new Relationship(
+                        collection: $collection->getId(),
+                        relatedCollection: $relatedCollection->getId(),
+                        type: $rel->type,
+                        twoWay: $rel->twoWay,
+                        key: $id,
+                        twoWayKey: $rel->twoWayKey,
+                        onDelete: $rel->onDelete,
+                        side: RelationSide::Parent,
+                    );
+                    $this->adapter->createRelationship($recreateRelModel);
+                } catch (Throwable) {
+                    // Silent rollback — best effort to restore consistency
+                }
+            }
+
+            // Restore deleted indexes
+            foreach ($deletedIndexes as $indexInfo) {
+                try {
+                    $this->createIndex(
+                        $indexInfo['collection'],
+                        new Index(
+                            key: $indexInfo['key'],
+                            type: $indexInfo['type'],
+                            attributes: $indexInfo['attributes']
+                        )
+                    );
+                } catch (Throwable) {
+                    // Silent rollback — best effort
+                }
+            }
+
+            // Restore junction collection metadata for M2M
+            if ($deletedJunction !== null && ! $deletedJunction->isEmpty()) {
+                try {
+                    $this->silent(fn () => $this->createDocument(self::METADATA, $deletedJunction));
+                } catch (Throwable) {
+                    // Silent rollback — best effort
+                }
+            }
+
+            throw new DatabaseException(
+                "Failed to persist metadata after retries for relationship deletion '{$id}': ".$e->getMessage(),
+                previous: $e
+            );
+        }
+
+        $this->withRetries(fn () => $this->purgeCachedCollection($collection->getId()));
+        $this->withRetries(fn () => $this->purgeCachedCollection($relatedCollection->getId()));
+
+        $this->triggerHooks(
+            Event::AttributeDelete,
+            (clone $relationship)->setAttribute(Document::COLLECTION, $collection->getId()),
+        );
+
+        return true;
+    }
+
+    private function getJunctionCollection(Document $collection, Document $relatedCollection, RelationSide $side): string
+    {
+        return $side === RelationSide::Parent
+            ? '_'.$collection->getSequence().'_'.$relatedCollection->getSequence()
+            : '_'.$relatedCollection->getSequence().'_'.$collection->getSequence();
+    }
+}
diff --git a/src/Database/Traits/Transactions.php b/src/Database/Traits/Transactions.php
new file mode 100644
index 0000000000..71ba4f4931
--- /dev/null
+++ b/src/Database/Traits/Transactions.php
@@ -0,0 +1,106 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Throwable;
+use Utopia\Database\Event;
+
+/**
+ * Provides transactional execution support, delegating to the underlying database adapter.
+ */
+trait Transactions
+{
+    /**
+     * Run a callback inside a transaction.
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     *
+     * @throws \Throwable
+     */
+    public function withTransaction(callable $callback): mixed
+    {
+        return $this->withInvalidationScope(fn () => $this->adapter->withTransaction($callback));
+    }
+
+    /**
+     * Run a mutation with mandatory cache invalidation ordered safely around it.
+     *
+     * A shared tombstone is published after the transaction starts but before
+     * the mutation. The outer scope activates a fresh epoch only after commit.
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     *
+     * @throws \Throwable
+     */
+    protected function withMutation(Event $event, mixed $data, callable $callback): mixed
+    {
+        return $this->withInvalidationScope(fn () => $this->adapter->withTransaction(function () use ($event, $data, $callback) {
+            $tokens = $this->getInvalidationTokens($event, $data);
+            $context = $this->getEventContext();
+            $pending = [];
+            foreach ($tokens as $collection => $token) {
+                if (isset($this->queryCacheMutations[$context][$collection])) {
+                    continue;
+                }
+
+                $pending[$collection] = $token;
+            }
+            $this->blockInvalidation($pending);
+            foreach ($pending as $collection => $token) {
+                $this->queryCacheMutations[$context][$collection] = $token;
+            }
+
+            return $callback();
+        }));
+    }
+
+    /**
+     * Keep all nested mutation tombstones blocked until the outer transaction
+     * has committed or rolled back.
+     *
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
+     *
+     * @throws Throwable
+     */
+    private function withInvalidationScope(callable $callback): mixed
+    {
+        $context = $this->getEventContext();
+        $outer = ! isset($this->queryCacheMutations[$context]);
+        if ($outer) {
+            $this->queryCacheMutations[$context] = [];
+        }
+
+        try {
+            $result = $callback();
+        } catch (Throwable $error) {
+            if ($outer) {
+                $tokens = $this->queryCacheMutations[$context];
+                unset($this->queryCacheMutations[$context]);
+                try {
+                    $this->activateInvalidation($tokens);
+                } catch (Throwable) {
+                    // A failed restore leaves the shared tombstone fail-closed.
+                }
+            }
+
+            throw $error;
+        }
+
+        if ($outer) {
+            $tokens = $this->queryCacheMutations[$context];
+            unset($this->queryCacheMutations[$context]);
+            $this->activateInvalidation($tokens);
+        }
+
+        return $result;
+    }
+}
diff --git a/src/Database/Type/Custom.php b/src/Database/Type/Custom.php
new file mode 100644
index 0000000000..e1b327274a
--- /dev/null
+++ b/src/Database/Type/Custom.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Type;
+
+use Utopia\Query\Schema\ColumnType;
+
+interface Custom
+{
+    public function name(): string;
+
+    public function columnType(): ColumnType;
+
+    public function columnSize(): int;
+
+    public function encode(mixed $value): mixed;
+
+    public function decode(mixed $value): mixed;
+}
diff --git a/src/Database/Type/Embeddable.php b/src/Database/Type/Embeddable.php
new file mode 100644
index 0000000000..b95918f3d5
--- /dev/null
+++ b/src/Database/Type/Embeddable.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Utopia\Database\Type;
+
+use Utopia\Database\Attribute;
+
+interface Embeddable
+{
+    public function name(): string;
+
+    /**
+     * @return array<Attribute>
+     */
+    public function attributes(): array;
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function decompose(mixed $value): array;
+
+    /**
+     * @param  array<string, mixed>  $values
+     */
+    public function compose(array $values): mixed;
+}
diff --git a/src/Database/Type/TypeRegistry.php b/src/Database/Type/TypeRegistry.php
new file mode 100644
index 0000000000..ef1e3d6b75
--- /dev/null
+++ b/src/Database/Type/TypeRegistry.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Utopia\Database\Type;
+
+use Utopia\Database\Database;
+
+class TypeRegistry
+{
+    /** @var array<string, Custom> */
+    private array $types = [];
+
+    /** @var array<string, Embeddable> */
+    private array $embeddables = [];
+
+    public function register(Custom $type): void
+    {
+        $this->types[$type->name()] = $type;
+
+        Database::addFilter(
+            $type->name(),
+            fn (mixed $value) => $type->encode($value),
+            fn (mixed $value) => $type->decode($value),
+        );
+    }
+
+    public function registerEmbeddable(Embeddable $type): void
+    {
+        $this->embeddables[$type->name()] = $type;
+    }
+
+    public function get(string $name): ?Custom
+    {
+        return $this->types[$name] ?? null;
+    }
+
+    public function getEmbeddable(string $name): ?Embeddable
+    {
+        return $this->embeddables[$name] ?? null;
+    }
+
+    /**
+     * @return array<string, Custom>
+     */
+    public function all(): array
+    {
+        return $this->types;
+    }
+
+    /**
+     * @return array<string, Embeddable>
+     */
+    public function allEmbeddables(): array
+    {
+        return $this->embeddables;
+    }
+}
diff --git a/src/Database/Validator/Attribute.php b/src/Database/Validator/Attribute.php
index e3dc0044e6..6ffc36fd0b 100644
--- a/src/Database/Validator/Attribute.php
+++ b/src/Database/Validator/Attribute.php
@@ -2,45 +2,39 @@
 
 namespace Utopia\Database\Validator;
 
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator;
+use ValueError;
 
+/**
+ * Validates database attribute definitions including type, size, format, and default values.
+ */
 class Attribute extends Validator
 {
     protected string $message = 'Invalid attribute';
 
     /**
-     * @var array<Document> $attributes
+     * @var array<string, AttributeVO>
      */
     protected array $attributes = [];
 
     /**
-     * @var array<Document> $schemaAttributes
+     * @var array<string, AttributeVO>
      */
     protected array $schemaAttributes = [];
 
     /**
-     * @param array<Document> $attributes
-     * @param array<Document> $schemaAttributes
-     * @param int $maxAttributes
-     * @param int $maxWidth
-     * @param int $maxStringLength
-     * @param int $maxVarcharLength
-     * @param int $maxIntLength
-     * @param int $maxBigIntLength
-     * @param bool $supportForSchemaAttributes
-     * @param bool $supportForVectors
-     * @param bool $supportForSpatialAttributes
-     * @param bool $supportForObject
-     * @param callable|null $attributeCountCallback
-     * @param callable|null $attributeWidthCallback
-     * @param callable|null $filterCallback
-     * @param bool $isMigrating
-     * @param bool $sharedTables
+     * @param  array<AttributeVO|Document>  $attributes
+     * @param  array<AttributeVO|Document>  $schemaAttributes
+     * @param  callable|null  $attributeCountCallback
+     * @param  callable|null  $attributeWidthCallback
+     * @param  callable|null  $filterCallback
      */
     public function __construct(
         array $attributes,
@@ -68,12 +62,12 @@ public function __construct(
         }
 
         foreach ($attributes as $attribute) {
-            $key = \strtolower($attribute->getAttribute('key', $attribute->getAttribute('$id')));
-            $this->attributes[$key] = $attribute;
+            $typed = $attribute instanceof AttributeVO ? $attribute : AttributeVO::fromDocument($attribute);
+            $this->attributes[\strtolower($typed->key)] = $typed;
         }
         foreach ($schemaAttributes as $attribute) {
-            $key = \strtolower($attribute->getAttribute('key', $attribute->getAttribute('$id')));
-            $this->schemaAttributes[$key] = $attribute;
+            $typed = $attribute instanceof AttributeVO ? $attribute : AttributeVO::fromDocument($attribute);
+            $this->schemaAttributes[\strtolower($typed->key)] = $typed;
         }
     }
 
@@ -81,8 +75,6 @@ public function __construct(
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
@@ -91,7 +83,6 @@ public function getType(): string
 
     /**
      * Returns validator description
-     * @return string
      */
     public function getDescription(): string
     {
@@ -102,8 +93,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -114,33 +103,47 @@ public function isArray(): bool
      * Is valid.
      *
      * Returns true if attribute is valid.
-     * @param Document $value
-     * @return bool
+     *
+     * @param  AttributeVO|Document  $value
+     *
      * @throws DatabaseException
      * @throws DuplicateException
      * @throws LimitException
      */
     public function isValid($value): bool
     {
-        if (!$this->checkDuplicateId($value)) {
+        if ($value instanceof AttributeVO) {
+            $attr = $value;
+        } else {
+            try {
+                $attr = AttributeVO::fromDocument($value);
+            } catch (ValueError $e) {
+                /** @var string $rawType */
+                $rawType = $value->getAttribute('type', 'unknown');
+                $this->message = 'Unknown attribute type: '.$rawType;
+                throw new DatabaseException($this->message);
+            }
+        }
+
+        if (! $this->checkDuplicateId($attr)) {
             return false;
         }
-        if (!$this->checkDuplicateInSchema($value)) {
+        if (! $this->checkDuplicateInSchema($attr)) {
             return false;
         }
-        if (!$this->checkRequiredFilters($value)) {
+        if (! $this->checkRequiredFilters($attr)) {
             return false;
         }
-        if (!$this->checkFormat($value)) {
+        if (! $this->checkFormat($attr)) {
             return false;
         }
-        if (!$this->checkAttributeLimits($value)) {
+        if (! $this->checkAttributeLimits($attr)) {
             return false;
         }
-        if (!$this->checkType($value)) {
+        if (! $this->checkType($attr)) {
             return false;
         }
-        if (!$this->checkDefaultValue($value)) {
+        if (! $this->checkDefaultValue($attr)) {
             return false;
         }
 
@@ -150,16 +153,14 @@ public function isValid($value): bool
     /**
      * Check for duplicate attribute ID in collection metadata
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DuplicateException
      */
-    public function checkDuplicateId(Document $attribute): bool
+    public function checkDuplicateId(AttributeVO $attribute): bool
     {
-        $id = $attribute->getAttribute('key', $attribute->getAttribute('$id'));
+        $id = $attribute->key;
 
         foreach ($this->attributes as $existingAttribute) {
-            if (\strtolower($existingAttribute->getId()) === \strtolower($id)) {
+            if (\strtolower($existingAttribute->key) === \strtolower($id)) {
                 $this->message = 'Attribute already exists in metadata';
                 throw new DuplicateException($this->message);
             }
@@ -171,13 +172,11 @@ public function checkDuplicateId(Document $attribute): bool
     /**
      * Check for duplicate attribute ID in schema
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DuplicateException
      */
-    public function checkDuplicateInSchema(Document $attribute): bool
+    public function checkDuplicateInSchema(AttributeVO $attribute): bool
     {
-        if (!$this->supportForSchemaAttributes) {
+        if (! $this->supportForSchemaAttributes) {
             return true;
         }
 
@@ -185,10 +184,11 @@ public function checkDuplicateInSchema(Document $attribute): bool
             return true;
         }
 
-        $id = $attribute->getAttribute('key', $attribute->getAttribute('$id'));
+        $id = $attribute->key;
 
         foreach ($this->schemaAttributes as $schemaAttribute) {
-            $schemaId = $this->filterCallback ? ($this->filterCallback)($schemaAttribute->getId()) : $schemaAttribute->getId();
+            /** @var string $schemaId */
+            $schemaId = $this->filterCallback ? ($this->filterCallback)($schemaAttribute->key) : $schemaAttribute->key;
             if (\strtolower($schemaId) === \strtolower($id)) {
                 $this->message = 'Attribute already exists in schema';
                 throw new DuplicateException($this->message);
@@ -201,18 +201,13 @@ public function checkDuplicateInSchema(Document $attribute): bool
     /**
      * Check if required filters are present for the attribute type
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkRequiredFilters(Document $attribute): bool
+    public function checkRequiredFilters(AttributeVO $attribute): bool
     {
-        $type = $attribute->getAttribute('type');
-        $filters = $attribute->getAttribute('filters', []);
-
-        $requiredFilters = $this->getRequiredFilters($type);
-        if (!empty(\array_diff($requiredFilters, $filters))) {
-            $this->message = "Attribute of type: $type requires the following filters: " . implode(",", $requiredFilters);
+        $requiredFilters = $this->getRequiredFilters($attribute->type);
+        if (! empty(\array_diff($requiredFilters, $attribute->filters))) {
+            $this->message = "Attribute of type: {$attribute->type->value} requires the following filters: ".implode(',', $requiredFilters);
             throw new DatabaseException($this->message);
         }
 
@@ -222,14 +217,12 @@ public function checkRequiredFilters(Document $attribute): bool
     /**
      * Get the list of required filters for each data type
      *
-     * @param string|null $type Type of the attribute
-     *
      * @return array<string>
      */
-    protected function getRequiredFilters(?string $type): array
+    protected function getRequiredFilters(ColumnType $type): array
     {
         return match ($type) {
-            Database::VAR_DATETIME => ['datetime'],
+            ColumnType::Datetime => ['datetime'],
             default => [],
         };
     }
@@ -237,17 +230,12 @@ protected function getRequiredFilters(?string $type): array
     /**
      * Check if format is valid for the attribute type
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkFormat(Document $attribute): bool
+    public function checkFormat(AttributeVO $attribute): bool
     {
-        $format = $attribute->getAttribute('format');
-        $type = $attribute->getAttribute('type');
-
-        if ($format && !Structure::hasFormat($format, $type)) {
-            $this->message = 'Format ("' . $format . '") not available for this attribute type ("' . $type . '")';
+        if ($attribute->format && ! Structure::hasFormat($attribute->format, $attribute->type)) {
+            $this->message = 'Format ("'.$attribute->format.'") not available for this attribute type ("'.$attribute->type->value.'")';
             throw new DatabaseException($this->message);
         }
 
@@ -257,26 +245,28 @@ public function checkFormat(Document $attribute): bool
     /**
      * Check attribute limits (count and width)
      *
-     * @param Document $attribute
-     * @return bool
      * @throws LimitException
      */
-    public function checkAttributeLimits(Document $attribute): bool
+    public function checkAttributeLimits(AttributeVO $attribute): bool
     {
         if ($this->attributeCountCallback === null || $this->attributeWidthCallback === null) {
             return true;
         }
 
-        $attributeCount = ($this->attributeCountCallback)($attribute);
-        $attributeWidth = ($this->attributeWidthCallback)($attribute);
+        $attributeDoc = $attribute->toDocument();
+
+        /** @var int $attributeCount */
+        $attributeCount = ($this->attributeCountCallback)($attributeDoc);
+        /** @var int $attributeWidth */
+        $attributeWidth = ($this->attributeWidthCallback)($attributeDoc);
 
         if ($this->maxAttributes > 0 && $attributeCount > $this->maxAttributes) {
-            $this->message = 'Column limit reached. Cannot create new attribute. Current attribute count is ' . $attributeCount . ' but the maximum is ' . $this->maxAttributes . '. Remove some attributes to free up space.';
+            $this->message = 'Column limit reached. Cannot create new attribute. Current attribute count is '.$attributeCount.' but the maximum is '.$this->maxAttributes.'. Remove some attributes to free up space.';
             throw new LimitException($this->message);
         }
 
         if ($this->maxWidth > 0 && $attributeWidth >= $this->maxWidth) {
-            $this->message = 'Row width limit reached. Cannot create new attribute. Current row width is ' . $attributeWidth . ' bytes but the maximum is ' . $this->maxWidth . ' bytes. Reduce the size of existing attributes or remove some attributes to free up space.';
+            $this->message = 'Row width limit reached. Cannot create new attribute. Current row width is '.$attributeWidth.' bytes but the maximum is '.$this->maxWidth.' bytes. Reduce the size of existing attributes or remove some attributes to free up space.';
             throw new LimitException($this->message);
         }
 
@@ -286,108 +276,109 @@ public function checkAttributeLimits(Document $attribute): bool
     /**
      * Check attribute type and type-specific constraints
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkType(Document $attribute): bool
+    public function checkType(AttributeVO $attribute): bool
     {
-        $type = $attribute->getAttribute('type');
-        $size = $attribute->getAttribute('size', 0);
-        $signed = $attribute->getAttribute('signed', true);
-        $array = $attribute->getAttribute('array', false);
-        $default = $attribute->getAttribute('default');
+        $type = $attribute->type;
+        $size = $attribute->size;
+        $signed = $attribute->signed;
+        $array = $attribute->array;
+        $default = $attribute->default;
 
         switch ($type) {
-            case Database::VAR_ID:
+            case ColumnType::Id:
                 break;
 
-            case Database::VAR_STRING:
+            case ColumnType::String:
                 if ($size > $this->maxStringLength) {
-                    $this->message = 'Max size allowed for string is: ' . number_format($this->maxStringLength);
+                    $this->message = 'Max size allowed for string is: '.number_format($this->maxStringLength);
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_VARCHAR:
+            case ColumnType::Varchar:
                 if ($size > $this->maxVarcharLength) {
-                    $this->message = 'Max size allowed for varchar is: ' . number_format($this->maxVarcharLength);
+                    $this->message = 'Max size allowed for varchar is: '.number_format($this->maxVarcharLength);
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_TEXT:
-                if ($size > Database::MAX_TEXT_BYTES) {
-                    $this->message = 'Max size allowed for text is: ' . Database::MAX_TEXT_BYTES;
+            case ColumnType::Text:
+                if ($size > 65535) {
+                    $this->message = 'Max size allowed for text is: 65535';
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_MEDIUMTEXT:
-                if ($size > Database::MAX_MEDIUMTEXT_BYTES) {
-                    $this->message = 'Max size allowed for mediumtext is: ' . Database::MAX_MEDIUMTEXT_BYTES;
+            case ColumnType::MediumText:
+                if ($size > 16777215) {
+                    $this->message = 'Max size allowed for mediumtext is: 16777215';
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_LONGTEXT:
-                if ($size > Database::MAX_LONGTEXT_BYTES) {
-                    $this->message = 'Max size allowed for longtext is: ' . Database::MAX_LONGTEXT_BYTES;
+            case ColumnType::LongText:
+                if ($size > 4294967295) {
+                    $this->message = 'Max size allowed for longtext is: 4294967295';
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_INTEGER:
+            case ColumnType::Integer:
+            case ColumnType::Serial:
+            case ColumnType::SmallSerial:
                 $limit = ($signed) ? $this->maxIntLength / 2 : $this->maxIntLength;
                 if ($size > $limit) {
-                    $this->message = 'Max size allowed for int is: ' . number_format($limit);
+                    $this->message = 'Max size allowed for int is: '.number_format($limit);
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_BIGINT:
+            case ColumnType::BigInteger:
+            case ColumnType::BigSerial:
+            case ColumnType::Float:
+            case ColumnType::Double:
+            case ColumnType::Boolean:
+            case ColumnType::Datetime:
+            case ColumnType::Timestamp:
+            case ColumnType::Relationship:
                 break;
 
-            case Database::VAR_FLOAT:
-            case Database::VAR_BOOLEAN:
-            case Database::VAR_DATETIME:
-            case Database::VAR_RELATIONSHIP:
-                break;
-
-            case Database::VAR_OBJECT:
-                if (!$this->supportForObject) {
+            case ColumnType::Object:
+                if (! $this->supportForObject) {
                     $this->message = 'Object attributes are not supported';
                     throw new DatabaseException($this->message);
                 }
-                if (!empty($size)) {
+                if (! empty($size)) {
                     $this->message = 'Size must be empty for object attributes';
                     throw new DatabaseException($this->message);
                 }
-                if (!empty($array)) {
+                if (! empty($array)) {
                     $this->message = 'Object attributes cannot be arrays';
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_POINT:
-            case Database::VAR_LINESTRING:
-            case Database::VAR_POLYGON:
-                if (!$this->supportForSpatialAttributes) {
+            case ColumnType::Point:
+            case ColumnType::Linestring:
+            case ColumnType::Polygon:
+                if (! $this->supportForSpatialAttributes) {
                     $this->message = 'Spatial attributes are not supported';
                     throw new DatabaseException($this->message);
                 }
-                if (!empty($size)) {
+                if (! empty($size)) {
                     $this->message = 'Size must be empty for spatial attributes';
                     throw new DatabaseException($this->message);
                 }
-                if (!empty($array)) {
+                if (! empty($array)) {
                     $this->message = 'Spatial attributes cannot be arrays';
                     throw new DatabaseException($this->message);
                 }
                 break;
 
-            case Database::VAR_VECTOR:
-                if (!$this->supportForVectors) {
+            case ColumnType::Vector:
+                if (! $this->supportForVectors) {
                     $this->message = 'Vector types are not supported by the current database';
                     throw new DatabaseException($this->message);
                 }
@@ -400,22 +391,22 @@ public function checkType(Document $attribute): bool
                     throw new DatabaseException($this->message);
                 }
                 if ($size > Database::MAX_VECTOR_DIMENSIONS) {
-                    $this->message = 'Vector dimensions cannot exceed ' . Database::MAX_VECTOR_DIMENSIONS;
+                    $this->message = 'Vector dimensions cannot exceed '.Database::MAX_VECTOR_DIMENSIONS;
                     throw new DatabaseException($this->message);
                 }
 
                 // Validate default value if provided
                 if ($default !== null) {
-                    if (!is_array($default)) {
+                    if (! is_array($default)) {
                         $this->message = 'Vector default value must be an array';
                         throw new DatabaseException($this->message);
                     }
                     if (count($default) !== $size) {
-                        $this->message = 'Vector default value must have exactly ' . $size . ' elements';
+                        $this->message = 'Vector default value must have exactly '.$size.' elements';
                         throw new DatabaseException($this->message);
                     }
                     foreach ($default as $component) {
-                        if (!is_numeric($component)) {
+                        if (! is_numeric($component)) {
                             $this->message = 'Vector default value must contain only numeric elements';
                             throw new DatabaseException($this->message);
                         }
@@ -425,28 +416,29 @@ public function checkType(Document $attribute): bool
 
             default:
                 $supportedTypes = [
-                    Database::VAR_STRING,
-                    Database::VAR_VARCHAR,
-                    Database::VAR_TEXT,
-                    Database::VAR_MEDIUMTEXT,
-                    Database::VAR_LONGTEXT,
-                    Database::VAR_INTEGER,
-                    Database::VAR_BIGINT,
-                    Database::VAR_FLOAT,
-                    Database::VAR_BOOLEAN,
-                    Database::VAR_DATETIME,
-                    Database::VAR_RELATIONSHIP
+                    ColumnType::String->value,
+                    ColumnType::Varchar->value,
+                    ColumnType::Text->value,
+                    ColumnType::MediumText->value,
+                    ColumnType::LongText->value,
+                    ColumnType::Integer->value,
+                    ColumnType::BigInteger->value,
+                    ColumnType::Float->value,
+                    ColumnType::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
                 ];
                 if ($this->supportForVectors) {
-                    $supportedTypes[] = Database::VAR_VECTOR;
+                    $supportedTypes[] = ColumnType::Vector->value;
                 }
                 if ($this->supportForSpatialAttributes) {
-                    \array_push($supportedTypes, ...Database::SPATIAL_TYPES);
+                    \array_push($supportedTypes, ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value);
                 }
                 if ($this->supportForObject) {
-                    $supportedTypes[] = Database::VAR_OBJECT;
+                    $supportedTypes[] = ColumnType::Object->value;
                 }
-                $this->message = 'Unknown attribute type: ' . $type . '. Must be one of ' . implode(', ', $supportedTypes);
+                $this->message = 'Unknown attribute type: '.$type->value.'. Must be one of '.implode(', ', $supportedTypes);
                 throw new DatabaseException($this->message);
         }
 
@@ -456,33 +448,39 @@ public function checkType(Document $attribute): bool
     /**
      * Check default value constraints and type matching
      *
-     * @param Document $attribute
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkDefaultValue(Document $attribute): bool
+    public function checkDefaultValue(AttributeVO $attribute): bool
     {
-        $default = $attribute->getAttribute('default');
-        $required = $attribute->getAttribute('required', false);
-        $type = $attribute->getAttribute('type');
-        $array = $attribute->getAttribute('array', false);
-        $signed = $attribute->getAttribute('signed', true);
+        $default = $attribute->default;
+        $type = $attribute->type;
+        $signed = $attribute->signed;
 
         if (\is_null($default)) {
             return true;
         }
 
-        if ($required === true) {
+        if ($attribute->required === true) {
             $this->message = 'Cannot set a default value for a required attribute';
             throw new DatabaseException($this->message);
         }
 
-        // Reject array defaults for non-array attributes (except vectors, spatial types, and objects which use arrays internally)
-        if (\is_array($default) && !$array && !\in_array($type, [Database::VAR_VECTOR, Database::VAR_OBJECT, ...Database::SPATIAL_TYPES], true)) {
+        // Reject array defaults for non-array attributes. Vectors, spatial types,
+        // objects, and json-filtered strings store structured values as arrays.
+        if (
+            \is_array($default)
+            && ! $attribute->array
+            && ! \in_array($type, [ColumnType::Vector, ColumnType::Object, ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)
+            && ! \in_array('json', $attribute->filters, true)
+        ) {
             $this->message = 'Cannot set an array default value for a non-array attribute';
             throw new DatabaseException($this->message);
         }
 
+        if (\in_array('json', $attribute->filters, true)) {
+            return true;
+        }
+
         $this->validateDefaultTypes($type, $default, $signed);
 
         return true;
@@ -491,14 +489,12 @@ public function checkDefaultValue(Document $attribute): bool
     /**
      * Function to validate if the default value of an attribute matches its attribute type
      *
-     * @param string $type Type of the attribute
-     * @param mixed $default Default value of the attribute
-     * @param bool $signed Whether the attribute is signed (relevant for bigint)
+     * @param  ColumnType  $type  Type of the attribute
+     * @param  mixed  $default  Default value of the attribute
      *
-     * @return void
      * @throws DatabaseException
      */
-    protected function validateDefaultTypes(string $type, mixed $default, bool $signed = true): void
+    protected function validateDefaultTypes(ColumnType $type, mixed $default, bool $signed = true): void
     {
         $defaultType = \gettype($default);
 
@@ -509,50 +505,63 @@ protected function validateDefaultTypes(string $type, mixed $default, bool $sign
 
         if ($defaultType === 'array') {
             // Spatial types require the array itself
-            if (!in_array($type, Database::SPATIAL_TYPES) && $type != Database::VAR_OBJECT) {
+            if (! in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon]) && $type !== ColumnType::Object) {
+                /** @var array<mixed> $default */
                 foreach ($default as $value) {
                     $this->validateDefaultTypes($type, $value, $signed);
                 }
             }
+
             return;
         }
 
         switch ($type) {
-            case Database::VAR_STRING:
-            case Database::VAR_VARCHAR:
-            case Database::VAR_TEXT:
-            case Database::VAR_MEDIUMTEXT:
-            case Database::VAR_LONGTEXT:
+            case ColumnType::String:
+            case ColumnType::Varchar:
+            case ColumnType::Text:
+            case ColumnType::MediumText:
+            case ColumnType::LongText:
                 if ($defaultType !== 'string') {
-                    $this->message = 'Default value ' . $default . ' does not match given type ' . $type;
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
                     throw new DatabaseException($this->message);
                 }
                 break;
-            case Database::VAR_INTEGER:
-            case Database::VAR_FLOAT:
-            case Database::VAR_BOOLEAN:
-                if ($type !== $defaultType) {
-                    $this->message = 'Default value ' . $default . ' does not match given type ' . $type;
+            case ColumnType::Integer:
+            case ColumnType::Boolean:
+                if ($type->value !== $defaultType) {
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
                     throw new DatabaseException($this->message);
                 }
                 break;
-            case Database::VAR_BIGINT:
-                if ($defaultType !== 'integer' && $defaultType !== 'string') {
-                    $this->message = 'Default value ' . $default . ' does not match given type ' . $type;
+            case ColumnType::Serial:
+            case ColumnType::SmallSerial:
+                if ($defaultType !== 'integer') {
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
                     throw new DatabaseException($this->message);
                 }
-                if ($defaultType === 'string' && !BigInt::isIntegerString($default, $signed)) {
-                    $this->message = 'Default value ' . $default . ' is not a valid integer string for type bigint';
+                break;
+            case ColumnType::BigInteger:
+            case ColumnType::BigSerial:
+                if (! (new BigInt($signed, $this->supportUnsignedBigInt))->isValid($default)) {
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
                     throw new DatabaseException($this->message);
                 }
                 break;
-            case Database::VAR_DATETIME:
-                if ($defaultType !== Database::VAR_STRING) {
-                    $this->message = 'Default value ' . $default . ' does not match given type ' . $type;
+            case ColumnType::Float:
+            case ColumnType::Double:
+                if ($defaultType !== 'double') {
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
+                    throw new DatabaseException($this->message);
+                }
+                break;
+            case ColumnType::Datetime:
+            case ColumnType::Timestamp:
+                if ($defaultType !== 'string') {
+                    $this->message = 'Default value '.json_encode($default).' does not match given type '.$type->value;
                     throw new DatabaseException($this->message);
                 }
                 break;
-            case Database::VAR_VECTOR:
+            case ColumnType::Vector:
                 // When validating individual vector components (from recursion), they should be numeric
                 if ($defaultType !== 'double' && $defaultType !== 'integer') {
                     $this->message = 'Vector components must be numeric values (float or integer)';
@@ -561,25 +570,26 @@ protected function validateDefaultTypes(string $type, mixed $default, bool $sign
                 break;
             default:
                 $supportedTypes = [
-                    Database::VAR_STRING,
-                    Database::VAR_VARCHAR,
-                    Database::VAR_TEXT,
-                    Database::VAR_MEDIUMTEXT,
-                    Database::VAR_LONGTEXT,
-                    Database::VAR_INTEGER,
-                    Database::VAR_BIGINT,
-                    Database::VAR_FLOAT,
-                    Database::VAR_BOOLEAN,
-                    Database::VAR_DATETIME,
-                    Database::VAR_RELATIONSHIP
+                    ColumnType::String->value,
+                    ColumnType::Varchar->value,
+                    ColumnType::Text->value,
+                    ColumnType::MediumText->value,
+                    ColumnType::LongText->value,
+                    ColumnType::Integer->value,
+                    ColumnType::BigInteger->value,
+                    ColumnType::Float->value,
+                    ColumnType::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
                 ];
                 if ($this->supportForVectors) {
-                    $supportedTypes[] = Database::VAR_VECTOR;
+                    $supportedTypes[] = ColumnType::Vector->value;
                 }
                 if ($this->supportForSpatialAttributes) {
-                    \array_push($supportedTypes, ...Database::SPATIAL_TYPES);
+                    \array_push($supportedTypes, ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value);
                 }
-                $this->message = 'Unknown attribute type: ' . $type . '. Must be one of ' . implode(', ', $supportedTypes);
+                $this->message = 'Unknown attribute type: '.$type->value.'. Must be one of '.implode(', ', $supportedTypes);
                 throw new DatabaseException($this->message);
         }
     }
diff --git a/src/Database/Validator/Authorization.php b/src/Database/Validator/Authorization.php
index 5f5ac179b2..8da1c6dad1 100644
--- a/src/Database/Validator/Authorization.php
+++ b/src/Database/Validator/Authorization.php
@@ -5,18 +5,16 @@
 use Utopia\Database\Validator\Authorization\Input;
 use Utopia\Validator;
 
+/**
+ * Validates authorization by checking if any of the current roles match the required permissions.
+ */
 class Authorization extends Validator
 {
-    /**
-     * @var bool
-     */
     protected bool $status = true;
 
     /**
      * Default value in case we need
      *  to reset Authorization status
-     *
-     * @var bool
      */
     protected bool $statusDefault = true;
 
@@ -24,47 +22,45 @@ class Authorization extends Validator
      * @var array<string, bool>
      */
     private array $roles = [
-        'any' => true
+        'any' => true,
     ];
 
-    /**
-     * @var string
-     */
     protected string $message = 'Authorization Error';
 
     /**
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
         return $this->message;
     }
 
-    /*
-     * Validation
+    /**
+     * Validate that the given input has the required permissions for the current roles.
      *
-     * Returns true if valid or false if not.
-    */
+     * @param mixed $input Authorization\Input instance containing action and permissions
+     * @return bool
+     */
     public function isValid(mixed $input): bool
     {
-        if (!($input instanceof Input)) {
+        if (! ($input instanceof Input)) {
             $this->message = 'Invalid input provided';
+
             return false;
         }
 
         $permissions = $input->getPermissions();
         $action = $input->getAction();
 
-        if (!$this->status) {
+        if (! $this->status) {
             return true;
         }
 
         if (empty($permissions)) {
             $this->message = 'No permissions provided for action \''.$action.'\'';
+
             return false;
         }
 
@@ -77,11 +73,14 @@ public function isValid(mixed $input): bool
         }
 
         $this->message = 'Missing "'.$action.'" permission for role "'.$permission.'". Only "'.\json_encode($this->getRoles()).'" scopes are allowed and "'.\json_encode($permissions).'" was given.';
+
         return false;
     }
 
     /**
-     * @param string $role
+     * Add a role to the authorized roles list.
+     *
+     * @param string $role Role identifier to add
      * @return void
      */
     public function addRole(string $role): void
@@ -90,8 +89,9 @@ public function addRole(string $role): void
     }
 
     /**
-     * @param string $role
+     * Remove a role from the authorized roles list.
      *
+     * @param string $role Role identifier to remove
      * @return void
      */
     public function removeRole(string $role): void
@@ -108,6 +108,8 @@ public function getRoles(): array
     }
 
     /**
+     * Remove all roles from the authorized roles list.
+     *
      * @return void
      */
     public function cleanRoles(): void
@@ -116,21 +118,20 @@ public function cleanRoles(): void
     }
 
     /**
-     * @param string $role
+     * Check whether a specific role exists in the authorized roles list.
      *
+     * @param string $role Role identifier to check
      * @return bool
      */
     public function hasRole(string $role): bool
     {
-        return (\array_key_exists($role, $this->roles));
+        return \array_key_exists($role, $this->roles);
     }
 
     /**
      * Change default status.
      * This will be used for the
      *  value set on the $this->reset() method
-     * @param bool $status
-     * @return void
      */
     public function setDefaultStatus(bool $status): void
     {
@@ -140,9 +141,6 @@ public function setDefaultStatus(bool $status): void
 
     /**
      * Change status
-     *
-     * @param bool $status
-     * @return void
      */
     public function setStatus(bool $status): void
     {
@@ -151,8 +149,6 @@ public function setStatus(bool $status): void
 
     /**
      * Get status
-     *
-     * @return bool
      */
     public function getStatus(): bool
     {
@@ -165,7 +161,8 @@ public function getStatus(): bool
      * Skips authorization for the code to be executed inside the callback
      *
      * @template T
-     * @param callable(): T $callback
+     *
+     * @param  callable(): T  $callback
      * @return T
      */
     public function skip(callable $callback): mixed
@@ -182,8 +179,6 @@ public function skip(callable $callback): mixed
 
     /**
      * Enable Authorization checks
-     *
-     * @return void
      */
     public function enable(): void
     {
@@ -192,8 +187,6 @@ public function enable(): void
 
     /**
      * Disable Authorization checks
-     *
-     * @return void
      */
     public function disable(): void
     {
@@ -202,8 +195,6 @@ public function disable(): void
 
     /**
      * Disable Authorization checks
-     *
-     * @return void
      */
     public function reset(): void
     {
@@ -214,8 +205,6 @@ public function reset(): void
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -226,8 +215,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Authorization/Input.php b/src/Database/Validator/Authorization/Input.php
index 8db9e80585..5a021152ec 100644
--- a/src/Database/Validator/Authorization/Input.php
+++ b/src/Database/Validator/Authorization/Input.php
@@ -2,39 +2,61 @@
 
 namespace Utopia\Database\Validator\Authorization;
 
+use Utopia\Database\PermissionType;
+
+/**
+ * Encapsulates the action and permissions used as input for authorization validation.
+ */
 class Input
 {
     /**
-     * @var array<string> $permissions
+     * @var array<string>
      */
     protected array $permissions;
+
     protected string $action;
 
     /**
-     * @param string[] $permissions
+     * Create a new authorization input.
+     *
+     * @param PermissionType|string $action The action being authorized (e.g., read, write)
+     * @param string[] $permissions List of permission strings to check against
      */
-    public function __construct(string $action, array $permissions)
+    public function __construct(PermissionType|string $action, array $permissions)
     {
         $this->permissions = $permissions;
-        $this->action = $action;
+        $this->action = $action instanceof PermissionType ? $action->value : $action;
     }
 
     /**
-     * @param string[] $permissions
+     * Set the permissions to check against.
+     *
+     * @param string[] $permissions List of permission strings
+     * @return self
      */
     public function setPermissions(array $permissions): self
     {
         $this->permissions = $permissions;
+
         return $this;
     }
 
-    public function setAction(string $action): self
+    /**
+     * Set the action being authorized.
+     *
+     * @param PermissionType|string $action The action name
+     * @return self
+     */
+    public function setAction(PermissionType|string $action): self
     {
-        $this->action = $action;
+        $this->action = $action instanceof PermissionType ? $action->value : $action;
+
         return $this;
     }
 
     /**
+     * Get the permissions to check against.
+     *
      * @return string[]
      */
     public function getPermissions(): array
@@ -42,6 +64,11 @@ public function getPermissions(): array
         return $this->permissions;
     }
 
+    /**
+     * Get the action being authorized.
+     *
+     * @return string
+     */
     public function getAction(): string
     {
         return $this->action;
diff --git a/src/Database/Validator/BigInt.php b/src/Database/Validator/BigInt.php
index fc560694a2..876e606287 100644
--- a/src/Database/Validator/BigInt.php
+++ b/src/Database/Validator/BigInt.php
@@ -2,14 +2,15 @@
 
 namespace Utopia\Database\Validator;
 
-use Utopia\Database\Database;
+use InvalidArgumentException;
+use Utopia\Database\OperatorType;
 use Utopia\Validator;
 
 class BigInt extends Validator
 {
-    public const SIGNED_MIN = '-9223372036854775808';
-    public const SIGNED_MAX = '9223372036854775807';
-    public const UNSIGNED_MAX = '18446744073709551615';
+    public const string SIGNED_MIN = '-9223372036854775808';
+    public const string SIGNED_MAX = '9223372036854775807';
+    public const string UNSIGNED_MAX = '18446744073709551615';
 
     public function __construct(
         private readonly bool $signed,
@@ -37,7 +38,7 @@ public function isArray(): bool
 
     public function getType(): string
     {
-        return Database::VAR_BIGINT;
+        return \Utopia\Query\Schema\ColumnType::BigInteger->value;
     }
 
     public function isValid(mixed $value): bool
@@ -123,6 +124,310 @@ public static function compareUnsignedStrings(string $a, string $b): int
         return $a < $b ? -1 : 1;
     }
 
+    public static function normalizeInteger(mixed $value): string
+    {
+        if (\is_float($value)) {
+            if (! \is_finite($value) || \floor($value) !== $value || $value < \PHP_INT_MIN || $value > \PHP_INT_MAX) {
+                throw new InvalidArgumentException('Value must be an integer.');
+            }
+            $value = (int) $value;
+        }
+        if (! \is_int($value) && ! \is_string($value)) {
+            throw new InvalidArgumentException('Value must be an integer.');
+        }
+        $value = (string) $value;
+        if (! self::isIntegerString($value)) {
+            throw new InvalidArgumentException('Value must be an integer.');
+        }
+
+        $negative = \str_starts_with($value, '-');
+        $digits = self::normalizeUnsignedString($negative ? \substr($value, 1) : $value);
+
+        return $negative && $digits !== '0' ? '-'.$digits : $digits;
+    }
+
+    public static function toNative(mixed $value): int|string
+    {
+        $value = self::normalizeInteger($value);
+
+        return self::fitsPhpInt($value) ? (int) $value : $value;
+    }
+
+    public static function compare(int|float|string $a, int|float|string $b): int
+    {
+        $a = self::normalizeInteger($a);
+        $b = self::normalizeInteger($b);
+        $aNegative = \str_starts_with($a, '-');
+        $bNegative = \str_starts_with($b, '-');
+
+        if ($aNegative !== $bNegative) {
+            return $aNegative ? -1 : 1;
+        }
+
+        $comparison = self::compareUnsignedStrings(\ltrim($a, '-'), \ltrim($b, '-'));
+
+        return $aNegative ? -$comparison : $comparison;
+    }
+
+    public static function add(int|float|string $a, int|float|string $b): int|string
+    {
+        $a = self::normalizeInteger($a);
+        $b = self::normalizeInteger($b);
+        $aNegative = \str_starts_with($a, '-');
+        $bNegative = \str_starts_with($b, '-');
+        $aDigits = \ltrim($a, '-');
+        $bDigits = \ltrim($b, '-');
+
+        if ($aNegative === $bNegative) {
+            $result = self::addUnsignedStrings($aDigits, $bDigits);
+            if ($aNegative && $result !== '0') {
+                $result = '-'.$result;
+            }
+
+            return self::toNative($result);
+        }
+
+        $comparison = self::compareUnsignedStrings($aDigits, $bDigits);
+        if ($comparison === 0) {
+            return 0;
+        }
+
+        $aLarger = $comparison > 0;
+        $result = self::subtractUnsignedStrings(
+            $aLarger ? $aDigits : $bDigits,
+            $aLarger ? $bDigits : $aDigits,
+        );
+        if (($aLarger ? $aNegative : $bNegative) && $result !== '0') {
+            $result = '-'.$result;
+        }
+
+        return self::toNative($result);
+    }
+
+    public static function subtract(int|float|string $a, int|float|string $b): int|string
+    {
+        return self::add($a, self::negate($b));
+    }
+
+    public static function negate(int|float|string $value): int|string
+    {
+        $value = self::normalizeInteger($value);
+        if ($value === '0') {
+            return 0;
+        }
+
+        return self::toNative(\str_starts_with($value, '-') ? \substr($value, 1) : '-'.$value);
+    }
+
+    public static function multiply(int|float|string $a, int|float|string $b): int|string
+    {
+        $a = self::normalizeInteger($a);
+        $b = self::normalizeInteger($b);
+        $negative = \str_starts_with($a, '-') !== \str_starts_with($b, '-');
+        $result = self::multiplyUnsignedStrings(\ltrim($a, '-'), \ltrim($b, '-'));
+        if ($negative && $result !== '0') {
+            $result = '-'.$result;
+        }
+
+        return self::toNative($result);
+    }
+
+    public static function divide(int|float|string $a, int|float|string $b): int|string
+    {
+        $a = self::normalizeInteger($a);
+        $b = self::normalizeInteger($b);
+        if ($b === '0') {
+            throw new InvalidArgumentException('Division by zero is not allowed.');
+        }
+
+        $negative = \str_starts_with($a, '-') !== \str_starts_with($b, '-');
+        [$quotient] = self::divideUnsignedStrings(\ltrim($a, '-'), \ltrim($b, '-'));
+        if ($negative && $quotient !== '0') {
+            $quotient = '-'.$quotient;
+        }
+
+        return self::toNative($quotient);
+    }
+
+    public static function modulo(int|float|string $a, int|float|string $b): int|string
+    {
+        $a = self::normalizeInteger($a);
+        $b = self::normalizeInteger($b);
+        if ($b === '0') {
+            throw new InvalidArgumentException('Modulo by zero is not allowed.');
+        }
+
+        [, $remainder] = self::divideUnsignedStrings(\ltrim($a, '-'), \ltrim($b, '-'));
+        if (\str_starts_with($a, '-') && $remainder !== '0') {
+            $remainder = '-'.$remainder;
+        }
+
+        return self::toNative($remainder);
+    }
+
+    public static function power(int|float|string $base, int|float|string $exponent): int|string
+    {
+        $base = self::normalizeInteger($base);
+        $exponent = self::normalizeInteger($exponent);
+        if (\str_starts_with($exponent, '-')) {
+            throw new InvalidArgumentException('Integer power exponent must not be negative.');
+        }
+        if ($exponent === '0') {
+            return 1;
+        }
+        if ($base === '0' || $base === '1') {
+            return (int) $base;
+        }
+        if ($base === '-1') {
+            return ((int) \substr($exponent, -1)) % 2 === 0 ? 1 : -1;
+        }
+        if (! self::fitsPhpInt($exponent, false) || (int) $exponent > 64) {
+            return \str_starts_with($base, '-') && ((int) \substr($exponent, -1)) % 2 !== 0
+                ? '-'.self::UNSIGNED_MAX.'0'
+                : self::UNSIGNED_MAX.'0';
+        }
+
+        $result = 1;
+        $factor = $base;
+        $remaining = (int) $exponent;
+        while ($remaining > 0) {
+            if ($remaining % 2 === 1) {
+                $result = self::multiply($result, $factor);
+            }
+            $remaining = \intdiv($remaining, 2);
+            if ($remaining > 0) {
+                $factor = self::multiply($factor, $factor);
+            }
+        }
+
+        return $result;
+    }
+
+    public static function calculate(OperatorType $method, int|float|string $current, int|float|string $operand): int|string
+    {
+        return match ($method) {
+            OperatorType::Increment => self::add($current, $operand),
+            OperatorType::Decrement => self::subtract($current, $operand),
+            OperatorType::Multiply => self::multiply($current, $operand),
+            OperatorType::Divide => self::divide($current, $operand),
+            OperatorType::Modulo => self::modulo($current, $operand),
+            OperatorType::Power => self::power($current, $operand),
+            default => throw new InvalidArgumentException('Operator must be numeric.'),
+        };
+    }
+
+    public static function calculateOutsideNative(OperatorType $method, mixed $current, mixed $operand): int|string|null
+    {
+        if (! self::isIntegerValue($current) || ! self::isIntegerValue($operand)) {
+            return null;
+        }
+
+        try {
+            $result = self::calculate($method, $current, $operand);
+        } catch (InvalidArgumentException) {
+            return null;
+        }
+
+        $currentOutside = \is_string($current) && ! self::fitsPhpInt($current);
+        $operandOutside = \is_string($operand) && ! self::fitsPhpInt($operand);
+
+        return $currentOutside || $operandOutside || \is_string($result) ? $result : null;
+    }
+
+    /**
+     * @phpstan-assert-if-true int|string $value
+     */
+    public static function isIntegerValue(mixed $value): bool
+    {
+        return \is_int($value) || (\is_string($value) && self::isIntegerString($value));
+    }
+
+    private static function addUnsignedStrings(string $a, string $b): string
+    {
+        $aIndex = \strlen($a) - 1;
+        $bIndex = \strlen($b) - 1;
+        $carry = 0;
+        $result = '';
+
+        while ($aIndex >= 0 || $bIndex >= 0 || $carry > 0) {
+            $sum = ($aIndex >= 0 ? (int) $a[$aIndex--] : 0)
+                + ($bIndex >= 0 ? (int) $b[$bIndex--] : 0)
+                + $carry;
+            $result = (string) ($sum % 10).$result;
+            $carry = \intdiv($sum, 10);
+        }
+
+        return self::normalizeUnsignedString($result);
+    }
+
+    private static function subtractUnsignedStrings(string $a, string $b): string
+    {
+        $aIndex = \strlen($a) - 1;
+        $bIndex = \strlen($b) - 1;
+        $borrow = 0;
+        $result = '';
+
+        while ($aIndex >= 0) {
+            $digit = (int) $a[$aIndex--] - $borrow - ($bIndex >= 0 ? (int) $b[$bIndex--] : 0);
+            if ($digit < 0) {
+                $digit += 10;
+                $borrow = 1;
+            } else {
+                $borrow = 0;
+            }
+            $result = (string) $digit.$result;
+        }
+
+        return self::normalizeUnsignedString($result);
+    }
+
+    private static function multiplyUnsignedStrings(string $a, string $b): string
+    {
+        $a = self::normalizeUnsignedString($a);
+        $b = self::normalizeUnsignedString($b);
+        if ($a === '0' || $b === '0') {
+            return '0';
+        }
+
+        $digits = \array_fill(0, \strlen($a) + \strlen($b), 0);
+        for ($aIndex = \strlen($a) - 1; $aIndex >= 0; $aIndex--) {
+            for ($bIndex = \strlen($b) - 1; $bIndex >= 0; $bIndex--) {
+                $position = $aIndex + $bIndex + 1;
+                $product = (int) $a[$aIndex] * (int) $b[$bIndex] + $digits[$position];
+                $digits[$position] = $product % 10;
+                $digits[$position - 1] += \intdiv($product, 10);
+            }
+        }
+
+        return self::normalizeUnsignedString(\implode('', $digits));
+    }
+
+    /**
+     * @return array{string, string}
+     */
+    private static function divideUnsignedStrings(string $dividend, string $divisor): array
+    {
+        $dividend = self::normalizeUnsignedString($dividend);
+        $divisor = self::normalizeUnsignedString($divisor);
+        if ($divisor === '0') {
+            throw new InvalidArgumentException('Division by zero is not allowed.');
+        }
+
+        $quotient = '';
+        $remainder = '0';
+        for ($index = 0, $length = \strlen($dividend); $index < $length; $index++) {
+            $remainder = self::normalizeUnsignedString($remainder.$dividend[$index]);
+            $digit = 0;
+            while (self::compareUnsignedStrings($remainder, $divisor) >= 0) {
+                $remainder = self::subtractUnsignedStrings($remainder, $divisor);
+                $digit++;
+            }
+            $quotient .= (string) $digit;
+        }
+
+        return [self::normalizeUnsignedString($quotient), $remainder];
+    }
+
     public static function formatIntegerString(string $value): string
     {
         $negative = \str_starts_with($value, '-');
diff --git a/src/Database/Validator/Datetime.php b/src/Database/Validator/Datetime.php
index 7950b1e078..3120285b59 100644
--- a/src/Database/Validator/Datetime.php
+++ b/src/Database/Validator/Datetime.php
@@ -2,61 +2,70 @@
 
 namespace Utopia\Database\Validator;
 
+use DateTime as PhpDateTime;
+use Exception;
 use Utopia\Validator;
 
+/**
+ * Validates datetime strings against configurable precision, range, and future-date constraints.
+ */
 class Datetime extends Validator
 {
     public const PRECISION_DAYS = 'days';
+
     public const PRECISION_HOURS = 'hours';
+
     public const PRECISION_MINUTES = 'minutes';
+
     public const PRECISION_SECONDS = 'seconds';
+
     public const PRECISION_ANY = 'any';
 
     /**
-     * @throws \Exception
+     * @throws Exception
      */
     public function __construct(
-        private readonly \DateTime $min = new \DateTime('0000-01-01'),
-        private readonly \DateTime $max = new \DateTime('9999-12-31'),
+        private readonly PhpDateTime $min = new PhpDateTime('0000-01-01'),
+        private readonly PhpDateTime $max = new PhpDateTime('9999-12-31'),
         private readonly bool $requireDateInFuture = false,
         private readonly string $precision = self::PRECISION_ANY,
         private readonly int $offset = 0,
     ) {
         if ($offset < 0) {
-            throw new \Exception('Offset must be a positive integer.');
+            throw new Exception('Offset must be a positive integer.');
         }
     }
 
     /**
      * Validator Description.
-     * @return string
      */
     public function getDescription(): string
     {
         $message = 'Value must be valid date';
 
         if ($this->offset > 0) {
-            $message .= " at least " . $this->offset . " seconds in the future and";
+            $message .= ' at least '.$this->offset.' seconds in the future and';
         } elseif ($this->requireDateInFuture) {
-            $message .= " in the future and";
+            $message .= ' in the future and';
         }
 
         if ($this->precision !== self::PRECISION_ANY) {
-            $message .= " with " . $this->precision . " precision";
+            $message .= ' with '.$this->precision.' precision';
         }
 
         $min = $this->min->format('Y-m-d H:i:s');
         $max = $this->max->format('Y-m-d H:i:s');
 
         $message .= " between {$min} and {$max}.";
+
         return $message;
     }
 
     /**
      * Is valid.
      * Returns true if valid or false if not.
-     * @param mixed $value
-     * @return bool
+     *
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
@@ -65,8 +74,8 @@ public function isValid($value): bool
         }
 
         try {
-            $date = new \DateTime($value);
-            $now = new \DateTime();
+            $date = new PhpDateTime($value);
+            $now = new PhpDateTime();
 
             if ($this->requireDateInFuture === true && $date < $now) {
                 return false;
@@ -80,38 +89,29 @@ public function isValid($value): bool
             }
 
             // Constants from: https://www.php.net/manual/en/datetime.format.php
-            $denyConstants = [];
-
-            switch ($this->precision) {
-                case self::PRECISION_DAYS:
-                    $denyConstants = [ 'H', 'i', 's', 'v' ];
-                    break;
-                case self::PRECISION_HOURS:
-                    $denyConstants = [ 'i', 's', 'v' ];
-                    break;
-                case self::PRECISION_MINUTES:
-                    $denyConstants = [ 's', 'v' ];
-                    break;
-                case self::PRECISION_SECONDS:
-                    $denyConstants = [ 'v' ];
-                    break;
-            }
+            $denyConstants = match ($this->precision) {
+                self::PRECISION_DAYS => ['H', 'i', 's', 'v'],
+                self::PRECISION_HOURS => ['i', 's', 'v'],
+                self::PRECISION_MINUTES => ['s', 'v'],
+                self::PRECISION_SECONDS => ['v'],
+                default => [],
+            };
 
             foreach ($denyConstants as $constant) {
                 if (\intval($date->format($constant)) !== 0) {
                     return false;
                 }
             }
-        } catch (\Exception) {
+        } catch (Exception) {
             return false;
         }
 
         // Custom year validation to account for PHP allowing year overflow
         $matches = [];
         if (preg_match('/(?<!\d)(\d{4})(?!\d)/', $value, $matches)) {
-            $year = (int)$matches[1];
-            $minYear = (int)$this->min->format('Y');
-            $maxYear = (int)$this->max->format('Y');
+            $year = (int) $matches[1];
+            $minYear = (int) $this->min->format('Y');
+            $maxYear = (int) $this->max->format('Y');
             if ($year < $minYear || $year > $maxYear) {
                 return false;
             }
@@ -130,8 +130,6 @@ public function isValid($value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -142,8 +140,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Index.php b/src/Database/Validator/Index.php
index 8b07db2ce1..2f446b1597 100644
--- a/src/Database/Validator/Index.php
+++ b/src/Database/Validator/Index.php
@@ -2,44 +2,43 @@
 
 namespace Utopia\Database\Validator;
 
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Index as IndexVO;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 use Utopia\Validator;
 
+/**
+ * Validates database index definitions including type support, attribute references, lengths, and constraints.
+ */
 class Index extends Validator
 {
     protected string $message = 'Invalid index';
 
     /**
-     * @var array<Document> $attributes
+     * @var array<string, AttributeVO>
      */
     protected array $attributes;
 
     /**
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @param int $maxLength
-     * @param array<string> $reservedKeys
-     * @param bool $supportForArrayIndexes
-     * @param bool $supportForSpatialIndexNull
-     * @param bool $supportForSpatialIndexOrder
-     * @param bool $supportForVectorIndexes
-     * @param bool $supportForAttributes
-     * @param bool $supportForMultipleFulltextIndexes
-     * @param bool $supportForIdenticalIndexes
-     * @param bool $supportForObjectIndexes
-     * @param bool $supportForTrigramIndexes
-     * @param bool $supportForSpatialIndexes
-     * @param bool $supportForKeyIndexes
-     * @param bool $supportForUniqueIndexes
-     * @param bool $supportForFulltextIndexes
-     * @param bool $supportForObjects
+     * @var array<IndexVO>
+     */
+    protected array $indexes;
+
+    /**
+     * @param  array<AttributeVO|Document>  $attributes
+     * @param  array<IndexVO|Document>  $indexes
+     * @param  array<string>  $reservedKeys
+     *
      * @throws DatabaseException
      */
     public function __construct(
         array $attributes,
-        protected array $indexes,
+        array $indexes,
         protected int $maxLength,
         protected array $reservedKeys = [],
         protected bool $supportForArrayIndexes = false,
@@ -58,13 +57,19 @@ public function __construct(
         protected bool $supportForTTLIndexes = false,
         protected bool $supportForObjects = false
     ) {
+        $this->attributes = [];
         foreach ($attributes as $attribute) {
-            $key = \strtolower($attribute->getAttribute('key', $attribute->getAttribute('$id')));
+            $typed = $attribute instanceof AttributeVO ? $attribute : AttributeVO::fromDocument($attribute);
+            $this->attributes[\strtolower($typed->key)] = $typed;
+        }
+        foreach (Database::internalAttributes() as $attribute) {
+            $key = \strtolower($attribute->key);
             $this->attributes[$key] = $attribute;
         }
-        foreach (Database::INTERNAL_ATTRIBUTES as $attribute) {
-            $key = \strtolower($attribute['$id']);
-            $this->attributes[$key] = new Document($attribute);
+
+        $this->indexes = [];
+        foreach ($indexes as $index) {
+            $this->indexes[] = $index instanceof IndexVO ? $index : IndexVO::fromDocument($index);
         }
     }
 
@@ -72,8 +77,6 @@ public function __construct(
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
@@ -82,7 +85,6 @@ public function getType(): string
 
     /**
      * Returns validator description
-     * @return string
      */
     public function getDescription(): string
     {
@@ -93,8 +95,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -105,362 +105,403 @@ public function isArray(): bool
      * Is valid.
      *
      * Returns true index if valid.
-     * @param Document $value
-     * @return bool
+     *
+     * @param  IndexVO|Document  $value
+     *
      * @throws DatabaseException
      */
     public function isValid($value): bool
     {
-        if (!$this->checkValidIndex($value)) {
+        $index = $value instanceof IndexVO ? $value : IndexVO::fromDocument($value);
+
+        if (! $this->checkValidIndex($index)) {
             return false;
         }
-        if (!$this->checkValidAttributes($value)) {
+        if (! $this->checkValidAttributes($index)) {
             return false;
         }
-        if (!$this->checkEmptyIndexAttributes($value)) {
+        if (! $this->checkEmptyIndexAttributes($index)) {
             return false;
         }
-        if (!$this->checkDuplicatedAttributes($value)) {
+        if (! $this->checkDuplicatedAttributes($index)) {
             return false;
         }
-        if (!$this->checkMultipleFulltextIndexes($value)) {
+        if (! $this->checkMultipleFulltextIndexes($index)) {
             return false;
         }
-        if (!$this->checkFulltextIndexNonString($value)) {
+        if (! $this->checkFulltextIndexNonString($index)) {
             return false;
         }
-        if (!$this->checkArrayIndexes($value)) {
+        if (! $this->checkArrayIndexes($index)) {
             return false;
         }
-        if (!$this->checkIndexLengths($value)) {
+        if (! $this->checkIndexLengths($index)) {
             return false;
         }
-        if (!$this->checkReservedNames($value)) {
+        if (! $this->checkReservedNames($index)) {
             return false;
         }
-        if (!$this->checkSpatialIndexes($value)) {
+        if (! $this->checkSpatialIndexes($index)) {
             return false;
         }
-        if (!$this->checkNonSpatialIndexOnSpatialAttributes($value)) {
+        if (! $this->checkNonSpatialIndexOnSpatialAttributes($index)) {
             return false;
         }
-        if (!$this->checkVectorIndexes($value)) {
+        if (! $this->checkVectorIndexes($index)) {
             return false;
         }
-        if (!$this->checkIdenticalIndexes($value)) {
+        if (! $this->checkIdenticalIndexes($index)) {
             return false;
         }
-        if (!$this->checkObjectIndexes($value)) {
+        if (! $this->checkObjectIndexes($index)) {
             return false;
         }
-        if (!$this->checkTrigramIndexes($value)) {
+        if (! $this->checkTrigramIndexes($index)) {
             return false;
         }
-        if (!$this->checkKeyUniqueFulltextSupport($value)) {
+        if (! $this->checkKeyUniqueFulltextSupport($index)) {
             return false;
         }
-        if (!$this->checkTTLIndexes($value)) {
+        if (! $this->checkTTLIndexes($index)) {
             return false;
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that the index type is supported by the current adapter.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
-    */
-    public function checkValidIndex(Document $index): bool
+     */
+    public function checkValidIndex(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
         if ($this->supportForObjects) {
             // getting dotted attributes not present in schema
-            $dottedAttributes = array_filter($index->getAttribute('attributes'), fn ($attr) => !isset($this->attributes[\strtolower($attr)]) && $this->isDottedAttribute($attr));
+            $dottedAttributes = array_filter($index->attributes, fn (string $attr) => ! isset($this->attributes[\strtolower($attr)]) && $this->isDottedAttribute($attr));
             if (\count($dottedAttributes)) {
                 foreach ($dottedAttributes as $attribute) {
                     $baseAttribute = $this->getBaseAttributeFromDottedAttribute($attribute);
-                    if (isset($this->attributes[\strtolower($baseAttribute)]) && $this->attributes[\strtolower($baseAttribute)]->getAttribute('type') != Database::VAR_OBJECT) {
-                        $this->message = 'Index attribute "' . $attribute . '" is only supported on object attributes';
-                        return false;
-                    };
+                    if (isset($this->attributes[\strtolower($baseAttribute)])) {
+                        $baseType = $this->attributes[\strtolower($baseAttribute)]->type;
+                        if ($baseType !== ColumnType::Object) {
+                            $this->message = 'Index attribute "'.$attribute.'" is only supported on object attributes';
+
+                            return false;
+                        }
+                    }
                 }
             }
         }
 
         switch ($type) {
-            case Database::INDEX_KEY:
-                if (!$this->supportForKeyIndexes) {
+            case IndexType::Key:
+                if (! $this->supportForKeyIndexes) {
                     $this->message = 'Key index is not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_UNIQUE:
-                if (!$this->supportForUniqueIndexes) {
+            case IndexType::Unique:
+                if (! $this->supportForUniqueIndexes) {
                     $this->message = 'Unique index is not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_FULLTEXT:
-                if (!$this->supportForFulltextIndexes) {
+            case IndexType::Fulltext:
+                if (! $this->supportForFulltextIndexes) {
                     $this->message = 'Fulltext index is not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_SPATIAL:
-                if (!$this->supportForSpatialIndexes) {
+            case IndexType::Spatial:
+                if (! $this->supportForSpatialIndexes) {
                     $this->message = 'Spatial indexes are not supported';
+
                     return false;
                 }
-                if (!empty($index->getAttribute('orders')) && !$this->supportForSpatialIndexOrder) {
+                if (! empty($index->orders) && ! $this->supportForSpatialIndexOrder) {
                     $this->message = 'Spatial indexes with explicit orders are not supported. Remove the orders to create this index.';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_HNSW_EUCLIDEAN:
-            case Database::INDEX_HNSW_COSINE:
-            case Database::INDEX_HNSW_DOT:
-                if (!$this->supportForVectorIndexes) {
+            case IndexType::HnswEuclidean:
+            case IndexType::HnswCosine:
+            case IndexType::HnswDot:
+                if (! $this->supportForVectorIndexes) {
                     $this->message = 'Vector indexes are not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_OBJECT:
-                if (!$this->supportForObjectIndexes) {
+            case IndexType::Object:
+                if (! $this->supportForObjectIndexes) {
                     $this->message = 'Object indexes are not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_TRIGRAM:
-                if (!$this->supportForTrigramIndexes) {
+            case IndexType::Trigram:
+                if (! $this->supportForTrigramIndexes) {
                     $this->message = 'Trigram indexes are not supported';
+
                     return false;
                 }
                 break;
 
-            case Database::INDEX_TTL:
-                if (!$this->supportForTTLIndexes) {
+            case IndexType::Ttl:
+                if (! $this->supportForTTLIndexes) {
                     $this->message = 'TTL indexes are not supported';
+
                     return false;
                 }
                 break;
 
             default:
-                $this->message = 'Unknown index type: ' . $type . '. Must be one of ' . Database::INDEX_KEY . ', ' . Database::INDEX_UNIQUE . ', ' . Database::INDEX_FULLTEXT . ', ' . Database::INDEX_SPATIAL . ', ' . Database::INDEX_OBJECT . ', ' . Database::INDEX_HNSW_EUCLIDEAN . ', ' . Database::INDEX_HNSW_COSINE . ', ' . Database::INDEX_HNSW_DOT . ', '.Database::INDEX_TRIGRAM . ', '.Database::INDEX_TTL;
+                $this->message = 'Unknown index type: '.$type->value.'. Must be one of '.IndexType::Key->value.', '.IndexType::Unique->value.', '.IndexType::Fulltext->value.', '.IndexType::Spatial->value.', '.IndexType::Object->value.', '.IndexType::HnswEuclidean->value.', '.IndexType::HnswCosine->value.', '.IndexType::HnswDot->value.', '.IndexType::Trigram->value.', '.IndexType::Ttl->value;
+
                 return false;
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that all index attributes exist in the collection schema.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkValidAttributes(Document $index): bool
+    public function checkValidAttributes(IndexVO $index): bool
     {
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
-        foreach ($index->getAttribute('attributes', []) as $attribute) {
+        foreach ($index->attributes as $attribute) {
             // attribute is part of the attributes
             // or object indexes supported and its a dotted attribute with base present in the attributes
-            if (!isset($this->attributes[\strtolower($attribute)])) {
+            if (! isset($this->attributes[\strtolower($attribute)])) {
                 if ($this->supportForObjects) {
                     $baseAttribute = $this->getBaseAttributeFromDottedAttribute($attribute);
                     if (isset($this->attributes[\strtolower($baseAttribute)])) {
                         continue;
                     }
                 }
-                $this->message = 'Invalid index attribute "' . $attribute . '" not found';
+                $this->message = 'Invalid index attribute "'.$attribute.'" not found';
+
                 return false;
             }
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that the index has at least one attribute.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkEmptyIndexAttributes(Document $index): bool
+    public function checkEmptyIndexAttributes(IndexVO $index): bool
     {
-        if (empty($index->getAttribute('attributes', []))) {
+        if (empty($index->attributes)) {
             $this->message = 'No attributes provided for index';
+
             return false;
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that the index does not contain duplicate attributes.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkDuplicatedAttributes(Document $index): bool
+    public function checkDuplicatedAttributes(IndexVO $index): bool
     {
-        $attributes = $index->getAttribute('attributes', []);
         $stack = [];
-        foreach ($attributes as $attribute) {
+        foreach ($index->attributes as $attribute) {
             $value = \strtolower($attribute);
 
             if (\in_array($value, $stack)) {
                 $this->message = 'Duplicate attributes provided';
+
                 return false;
             }
 
             $stack[] = $value;
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that fulltext indexes only reference string-type attributes.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkFulltextIndexNonString(Document $index): bool
+    public function checkFulltextIndexNonString(IndexVO $index): bool
     {
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
-        if ($index->getAttribute('type') === Database::INDEX_FULLTEXT) {
-            foreach ($index->getAttribute('attributes', []) as $attribute) {
-                $attribute = $this->attributes[\strtolower($attribute)] ?? new Document();
-                $attributeType = $attribute->getAttribute('type', '');
+        if ($index->type === IndexType::Fulltext) {
+            foreach ($index->attributes as $attributeName) {
+                $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+                $attributeType = $attribute->type;
                 $validFulltextTypes = [
-                    Database::VAR_STRING,
-                    Database::VAR_VARCHAR,
-                    Database::VAR_TEXT,
-                    Database::VAR_MEDIUMTEXT,
-                    Database::VAR_LONGTEXT
+                    ColumnType::String,
+                    ColumnType::Varchar,
+                    ColumnType::Text,
+                    ColumnType::MediumText,
+                    ColumnType::LongText,
                 ];
-                if (!in_array($attributeType, $validFulltextTypes)) {
-                    $this->message = 'Attribute "' . $attribute->getAttribute('key', $attribute->getAttribute('$id')) . '" cannot be part of a fulltext index, must be of type string';
+                if (! in_array($attributeType, $validFulltextTypes)) {
+                    $this->message = 'Attribute "'.$attribute->key.'" cannot be part of a fulltext index, must be of type string';
+
                     return false;
                 }
             }
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check constraints for indexes on array attributes including type, length, and count limits.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkArrayIndexes(Document $index): bool
+    public function checkArrayIndexes(IndexVO $index): bool
     {
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
-        $attributes = $index->getAttribute('attributes', []);
-        $orders = $index->getAttribute('orders', []);
-        $lengths = $index->getAttribute('lengths', []);
 
         $arrayAttributes = [];
-        foreach ($attributes as $attributePosition => $attributeName) {
-            $attribute = $this->attributes[\strtolower($attributeName)] ?? new Document();
+        foreach ($index->attributes as $attributePosition => $attributeName) {
+            $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
 
-            if ($attribute->getAttribute('array', false)) {
+            if ($attribute->array) {
                 // Database::INDEX_UNIQUE Is not allowed! since mariaDB VS MySQL makes the unique Different on values
-                if ($index->getAttribute('type') != Database::INDEX_KEY) {
-                    $this->message = '"' . ucfirst($index->getAttribute('type')) . '" index is forbidden on array attributes';
+                if ($index->type !== IndexType::Key) {
+                    $this->message = '"'.ucfirst($index->type->value).'" index is forbidden on array attributes';
+
                     return false;
                 }
 
-                if (empty($lengths[$attributePosition])) {
+                if (empty($index->lengths[$attributePosition])) {
                     $this->message = 'Index length for array not specified';
+
                     return false;
                 }
 
-                $arrayAttributes[] = $attribute->getAttribute('key', '');
+                $arrayAttributes[] = $attribute->key;
                 if (count($arrayAttributes) > 1) {
                     $this->message = 'An index may only contain one array attribute';
+
                     return false;
                 }
 
-                $direction = $orders[$attributePosition] ?? '';
-                if (!empty($direction)) {
-                    $this->message = 'Invalid index order "' . $direction . '" on array attribute "' . $attribute->getAttribute('key', '') . '"';
+                $direction = $index->orders[$attributePosition] ?? null;
+                if ($direction !== null) {
+                    $this->message = 'Invalid index order "'.$direction->value.'" on array attribute "'.$attribute->key.'"';
+
                     return false;
                 }
 
                 if ($this->supportForArrayIndexes === false) {
                     $this->message = 'Indexing an array attribute is not supported';
+
                     return false;
                 }
-            } elseif (!in_array($attribute->getAttribute('type'), [
-                Database::VAR_STRING,
-                Database::VAR_VARCHAR,
-                Database::VAR_TEXT,
-                Database::VAR_MEDIUMTEXT,
-                Database::VAR_LONGTEXT
-            ]) && !empty($lengths[$attributePosition])) {
-                $this->message = 'Cannot set a length on "' . $attribute->getAttribute('type') . '" attributes';
+            } elseif (! in_array($attribute->type, [
+                ColumnType::String,
+                ColumnType::Varchar,
+                ColumnType::Text,
+                ColumnType::MediumText,
+                ColumnType::LongText,
+            ]) && ! empty($index->lengths[$attributePosition])) {
+                $this->message = 'Cannot set a length on "'.$attribute->type->value.'" attributes';
+
                 return false;
             }
         }
+
         return true;
     }
 
     /**
-     * @param Document $index
+     * Check that index lengths are valid and do not exceed the maximum allowed total.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkIndexLengths(Document $index): bool
+    public function checkIndexLengths(IndexVO $index): bool
     {
-        if ($index->getAttribute('type') === Database::INDEX_FULLTEXT) {
+        if ($index->type === IndexType::Fulltext) {
             return true;
         }
 
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
 
         $total = 0;
-        $lengths = $index->getAttribute('lengths', []);
-        $attributes = $index->getAttribute('attributes', []);
-        if (count($lengths) > count($attributes)) {
+        if (count($index->lengths) > count($index->attributes)) {
             $this->message = 'Invalid index lengths. Count of lengths must be equal or less than the number of attributes.';
+
             return false;
         }
-        foreach ($attributes as $attributePosition => $attributeName) {
-            if ($this->supportForObjects && !isset($this->attributes[\strtolower($attributeName)])) {
+        foreach ($index->attributes as $attributePosition => $attributeName) {
+            if ($this->supportForObjects && ! isset($this->attributes[\strtolower($attributeName)])) {
                 $attributeName = $this->getBaseAttributeFromDottedAttribute($attributeName);
             }
             $attribute = $this->attributes[\strtolower($attributeName)];
 
-            switch ($attribute->getAttribute('type')) {
-                case Database::VAR_STRING:
-                case Database::VAR_VARCHAR:
-                case Database::VAR_TEXT:
-                case Database::VAR_MEDIUMTEXT:
-                case Database::VAR_LONGTEXT:
-                    $attributeSize = $attribute->getAttribute('size', 0);
-                    $indexLength = !empty($lengths[$attributePosition]) ? $lengths[$attributePosition] : $attributeSize;
-                    break;
-                case Database::VAR_FLOAT:
-                    $attributeSize = 2; // 8 bytes / 4 mb4
-                    $indexLength = 2;
-                    break;
-                default:
-                    $attributeSize = 1; // 4 bytes / 4 mb4
-                    $indexLength = 1;
-                    break;
-            }
+            $attrType = $attribute->type;
+            $attrSize = $attribute->size;
+            [$attributeSize, $indexLength] = match ($attrType) {
+                ColumnType::String,
+                ColumnType::Varchar,
+                ColumnType::Text,
+                ColumnType::MediumText,
+                ColumnType::LongText => [
+                    $attrSize,
+                    ! empty($index->lengths[$attributePosition]) ? $index->lengths[$attributePosition] : $attrSize,
+                ],
+                ColumnType::Double => [2, 2],
+                default => [1, 1],
+            };
             if ($indexLength < 0) {
-                $this->message = 'Negative index length provided for ' . $attributeName;
+                $this->message = 'Negative index length provided for '.$attributeName;
+
                 return false;
             }
 
-            if ($attribute->getAttribute('array', false)) {
+            if ($attribute->array) {
                 $attributeSize = Database::MAX_ARRAY_INDEX_LENGTH;
                 $indexLength = Database::MAX_ARRAY_INDEX_LENGTH;
             }
 
             if ($indexLength > $attributeSize) {
-                $this->message = 'Index length ' . $indexLength . ' is larger than the size for ' . $attributeName . ': ' . $attributeSize . '"';
+                $this->message = 'Index length '.$indexLength.' is larger than the size for '.$attributeName.': '.$attributeSize.'"';
+
                 return false;
             }
 
@@ -468,7 +509,8 @@ public function checkIndexLengths(Document $index): bool
         }
 
         if ($total > $this->maxLength && $this->maxLength > 0) {
-            $this->message = 'Index length is longer than the maximum: ' . $this->maxLength;
+            $this->message = 'Index length is longer than the maximum: '.$this->maxLength;
+
             return false;
         }
 
@@ -476,16 +518,19 @@ public function checkIndexLengths(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check that the index key name is not a reserved name.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkReservedNames(Document $index): bool
+    public function checkReservedNames(IndexVO $index): bool
     {
-        $key = $index->getAttribute('key', $index->getAttribute('$id'));
+        $key = $index->key;
 
         foreach ($this->reservedKeys as $reserved) {
             if (\strtolower($key) === \strtolower($reserved)) {
                 $this->message = 'Index key name is reserved';
+
                 return false;
             }
         }
@@ -494,48 +539,51 @@ public function checkReservedNames(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check spatial index constraints including attribute type and nullability.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkSpatialIndexes(Document $index): bool
+    public function checkSpatialIndexes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
-        if ($type !== Database::INDEX_SPATIAL) {
+        if ($type !== IndexType::Spatial) {
             return true;
         }
 
         if ($this->supportForSpatialIndexes === false) {
             $this->message = 'Spatial indexes are not supported';
+
             return false;
         }
 
-        $attributes = $index->getAttribute('attributes', []);
-        $orders = $index->getAttribute('orders', []);
-
-        if (\count($attributes) !== 1) {
+        if (\count($index->attributes) !== 1) {
             $this->message = 'Spatial index must have exactly one attribute';
+
             return false;
         }
 
-        foreach ($attributes as $attributeName) {
-            $attribute = $this->attributes[\strtolower($attributeName)] ?? new Document();
-            $attributeType = $attribute->getAttribute('type', '');
+        foreach ($index->attributes as $attributeName) {
+            $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+            $attributeType = $attribute->type;
+
+            if (! \in_array($attributeType, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+                $this->message = 'Spatial index can only be created on spatial attributes (point, linestring, polygon). Attribute "'.$attributeName.'" is of type "'.$attributeType->value.'"';
 
-            if (!\in_array($attributeType, Database::SPATIAL_TYPES, true)) {
-                $this->message = 'Spatial index can only be created on spatial attributes (point, linestring, polygon). Attribute "' . $attributeName . '" is of type "' . $attributeType . '"';
                 return false;
             }
 
-            $required = (bool)$attribute->getAttribute('required', false);
-            if (!$required && !$this->supportForSpatialIndexNull) {
-                $this->message = 'Spatial indexes do not allow null values. Mark the attribute "' . $attributeName . '" as required or create the index on a column with no null values.';
+            if (! $attribute->required && ! $this->supportForSpatialIndexNull) {
+                $this->message = 'Spatial indexes do not allow null values. Mark the attribute "'.$attributeName.'" as required or create the index on a column with no null values.';
+
                 return false;
             }
         }
 
-        if (!empty($orders) && !$this->supportForSpatialIndexOrder) {
+        if (! empty($index->orders) && ! $this->supportForSpatialIndexOrder) {
             $this->message = 'Spatial indexes with explicit orders are not supported. Remove the orders to create this index.';
+
             return false;
         }
 
@@ -543,26 +591,27 @@ public function checkSpatialIndexes(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check that non-spatial index types are not applied to spatial attributes.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkNonSpatialIndexOnSpatialAttributes(Document $index): bool
+    public function checkNonSpatialIndexOnSpatialAttributes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
         // Skip check for spatial indexes
-        if ($type === Database::INDEX_SPATIAL) {
+        if ($type === IndexType::Spatial) {
             return true;
         }
 
-        $attributes = $index->getAttribute('attributes', []);
+        foreach ($index->attributes as $attributeName) {
+            $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+            $attributeType = $attribute->type;
 
-        foreach ($attributes as $attributeName) {
-            $attribute = $this->attributes[\strtolower($attributeName)] ?? new Document();
-            $attributeType = $attribute->getAttribute('type', '');
+            if (\in_array($attributeType, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+                $this->message = 'Cannot create '.$type->value.' index on spatial attribute "'.$attributeName.'". Spatial attributes require spatial indexes.';
 
-            if (\in_array($attributeType, Database::SPATIAL_TYPES, true)) {
-                $this->message = 'Cannot create ' . $type . ' index on spatial attribute "' . $attributeName . '". Spatial attributes require spatial indexes.';
                 return false;
             }
         }
@@ -571,44 +620,42 @@ public function checkNonSpatialIndexOnSpatialAttributes(Document $index): bool
     }
 
     /**
-     * @param Document $index
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkVectorIndexes(Document $index): bool
+    public function checkVectorIndexes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
         if (
-            $type !== Database::INDEX_HNSW_DOT &&
-            $type !== Database::INDEX_HNSW_COSINE &&
-            $type !== Database::INDEX_HNSW_EUCLIDEAN
+            $type !== IndexType::HnswDot &&
+            $type !== IndexType::HnswCosine &&
+            $type !== IndexType::HnswEuclidean
         ) {
             return true;
         }
 
         if ($this->supportForVectorIndexes === false) {
             $this->message = 'Vector indexes are not supported';
+
             return false;
         }
 
-        $attributes = $index->getAttribute('attributes', []);
-
-        if (\count($attributes) !== 1) {
+        if (\count($index->attributes) !== 1) {
             $this->message = 'Vector index must have exactly one attribute';
+
             return false;
         }
 
-        $attribute = $this->attributes[\strtolower($attributes[0])] ?? new Document();
-        if ($attribute->getAttribute('type') !== Database::VAR_VECTOR) {
+        $attribute = $this->attributes[\strtolower($index->attributes[0])] ?? new AttributeVO();
+        if ($attribute->type !== ColumnType::Vector) {
             $this->message = 'Vector index can only be created on vector attributes';
+
             return false;
         }
 
-        $orders = $index->getAttribute('orders', []);
-        $lengths = $index->getAttribute('lengths', []);
-        if (!empty($orders) || \count(\array_filter($lengths)) > 0) {
+        if (! empty($index->orders) || \count(\array_filter($index->lengths)) > 0) {
             $this->message = 'Vector indexes do not support orders or lengths';
+
             return false;
         }
 
@@ -616,45 +663,42 @@ public function checkVectorIndexes(Document $index): bool
     }
 
     /**
-     * @param Document $index
-     * @return bool
      * @throws DatabaseException
      */
-    public function checkTrigramIndexes(Document $index): bool
+    public function checkTrigramIndexes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
-        if ($type !== Database::INDEX_TRIGRAM) {
+        if ($type !== IndexType::Trigram) {
             return true;
         }
 
         if ($this->supportForTrigramIndexes === false) {
             $this->message = 'Trigram indexes are not supported';
+
             return false;
         }
 
-        $attributes = $index->getAttribute('attributes', []);
-
         $validStringTypes = [
-            Database::VAR_STRING,
-            Database::VAR_VARCHAR,
-            Database::VAR_TEXT,
-            Database::VAR_MEDIUMTEXT,
-            Database::VAR_LONGTEXT
+            ColumnType::String,
+            ColumnType::Varchar,
+            ColumnType::Text,
+            ColumnType::MediumText,
+            ColumnType::LongText,
         ];
 
-        foreach ($attributes as $attributeName) {
-            $attribute = $this->attributes[\strtolower($attributeName)] ?? new Document();
-            if (!in_array($attribute->getAttribute('type', ''), $validStringTypes)) {
+        foreach ($index->attributes as $attributeName) {
+            $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+            if (! in_array($attribute->type, $validStringTypes)) {
                 $this->message = 'Trigram index can only be created on string type attributes';
+
                 return false;
             }
         }
 
-        $orders = $index->getAttribute('orders', []);
-        $lengths = $index->getAttribute('lengths', []);
-        if (!empty($orders) || \count(\array_filter($lengths)) > 0) {
+        if (! empty($index->orders) || \count(\array_filter($index->lengths)) > 0) {
             $this->message = 'Trigram indexes do not support orders or lengths';
+
             return false;
         }
 
@@ -662,20 +706,24 @@ public function checkTrigramIndexes(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check that key and unique index types are supported by the current adapter.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkKeyUniqueFulltextSupport(Document $index): bool
+    public function checkKeyUniqueFulltextSupport(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
-        if ($type === Database::INDEX_KEY && $this->supportForKeyIndexes === false) {
+        if ($type === IndexType::Key && $this->supportForKeyIndexes === false) {
             $this->message = 'Key index is not supported';
+
             return false;
         }
 
-        if ($type === Database::INDEX_UNIQUE && $this->supportForUniqueIndexes === false) {
+        if ($type === IndexType::Unique && $this->supportForUniqueIndexes === false) {
             $this->message = 'Unique index is not supported';
+
             return false;
         }
 
@@ -683,22 +731,25 @@ public function checkKeyUniqueFulltextSupport(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check that multiple fulltext indexes are not created when unsupported.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkMultipleFulltextIndexes(Document $index): bool
+    public function checkMultipleFulltextIndexes(IndexVO $index): bool
     {
         if ($this->supportForMultipleFulltextIndexes) {
             return true;
         }
 
-        if ($index->getAttribute('type') === Database::INDEX_FULLTEXT) {
+        if ($index->type === IndexType::Fulltext) {
             foreach ($this->indexes as $existingIndex) {
-                if ($existingIndex->getId() === $index->getId()) {
+                if ($existingIndex->key === $index->key) {
                     continue;
                 }
-                if ($existingIndex->getAttribute('type') === Database::INDEX_FULLTEXT) {
+                if ($existingIndex->type === IndexType::Fulltext) {
                     $this->message = 'There is already a fulltext index in the collection';
+
                     return false;
                 }
             }
@@ -708,45 +759,42 @@ public function checkMultipleFulltextIndexes(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check that identical indexes (same attributes and orders) are not created when unsupported.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
      */
-    public function checkIdenticalIndexes(Document $index): bool
+    public function checkIdenticalIndexes(IndexVO $index): bool
     {
         if ($this->supportForIdenticalIndexes) {
             return true;
         }
 
-        $indexAttributes = $index->getAttribute('attributes', []);
-        $indexOrders = $index->getAttribute('orders', []);
-        $indexType = $index->getAttribute('type', '');
-
         foreach ($this->indexes as $existingIndex) {
-            $existingAttributes = $existingIndex->getAttribute('attributes', []);
-            $existingOrders = $existingIndex->getAttribute('orders', []);
-            $existingType = $existingIndex->getAttribute('type', '');
-
             $attributesMatch = false;
-            if (empty(\array_diff($existingAttributes, $indexAttributes)) &&
-                empty(\array_diff($indexAttributes, $existingAttributes))) {
+            if (empty(\array_diff($existingIndex->attributes, $index->attributes)) &&
+                empty(\array_diff($index->attributes, $existingIndex->attributes))) {
                 $attributesMatch = true;
             }
 
             $ordersMatch = false;
-            if (empty(\array_diff($existingOrders, $indexOrders)) &&
-                empty(\array_diff($indexOrders, $existingOrders))) {
+            $existingOrders = self::orderValues($existingIndex);
+            $incomingOrders = self::orderValues($index);
+            if (empty(\array_diff($existingOrders, $incomingOrders)) &&
+                empty(\array_diff($incomingOrders, $existingOrders))) {
                 $ordersMatch = true;
             }
 
             if ($attributesMatch && $ordersMatch) {
                 // Allow fulltext + key/unique combinations (different purposes)
-                $regularTypes = [Database::INDEX_KEY, Database::INDEX_UNIQUE];
-                $isRegularIndex = \in_array($indexType, $regularTypes);
-                $isRegularExisting = \in_array($existingType, $regularTypes);
+                $regularTypes = [IndexType::Key, IndexType::Unique];
+                $isRegularIndex = \in_array($index->type, $regularTypes);
+                $isRegularExisting = \in_array($existingIndex->type, $regularTypes);
 
                 // Only reject if both are regular index types (key or unique)
                 if ($isRegularIndex && $isRegularExisting) {
                     $this->message = 'There is already an index with the same attributes and orders';
+
                     return false;
                 }
             }
@@ -756,94 +804,105 @@ public function checkIdenticalIndexes(Document $index): bool
     }
 
     /**
-     * @param Document $index
+     * Check object index constraints including single-attribute and top-level requirements.
+     *
+     * @param IndexVO $index The index to validate
      * @return bool
-    */
-    public function checkObjectIndexes(Document $index): bool
+     */
+    public function checkObjectIndexes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
-
-        $attributes = $index->getAttribute('attributes', []);
-        $orders     = $index->getAttribute('orders', []);
+        $type = $index->type;
 
-        if ($type !== Database::INDEX_OBJECT) {
+        if ($type !== IndexType::Object) {
             return true;
         }
 
-        if (!$this->supportForObjectIndexes) {
+        if (! $this->supportForObjectIndexes) {
             $this->message = 'Object indexes are not supported';
+
             return false;
         }
 
-        if (count($attributes) !== 1) {
+        if (count($index->attributes) !== 1) {
             $this->message = 'Object index can be created on a single object attribute';
+
             return false;
         }
 
-        if (!empty($orders)) {
+        if (! empty($index->orders)) {
             $this->message = 'Object index do not support explicit orders. Remove the orders to create this index.';
+
             return false;
         }
 
-        $attributeName = $attributes[0] ?? '';
+        $attributeName = (string) ($index->attributes[0] ?? '');
 
         // Object indexes are only allowed on the top-level object attribute,
         // not on nested paths like "data.key.nestedKey".
         if (\strpos($attributeName, '.') !== false) {
             $this->message = 'Object index can only be created on a top-level object attribute';
+
             return false;
         }
 
-        $attribute     = $this->attributes[\strtolower($attributeName)] ?? new Document();
-        $attributeType = $attribute->getAttribute('type', '');
+        $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+        $attributeType = $attribute->type;
+
+        if ($attributeType !== ColumnType::Object) {
+            $this->message = 'Object index can only be created on object attributes. Attribute "'.$attributeName.'" is of type "'.$attributeType->value.'"';
 
-        if ($attributeType !== Database::VAR_OBJECT) {
-            $this->message = 'Object index can only be created on object attributes. Attribute "' . $attributeName . '" is of type "' . $attributeType . '"';
             return false;
         }
 
         return true;
     }
 
-    public function checkTTLIndexes(Document $index): bool
+    /**
+     * Check TTL index constraints including single-attribute, datetime type, and uniqueness requirements.
+     *
+     * @param IndexVO $index The index to validate
+     * @return bool
+     */
+    public function checkTTLIndexes(IndexVO $index): bool
     {
-        $type = $index->getAttribute('type');
+        $type = $index->type;
 
-        $attributes = $index->getAttribute('attributes', []);
-        $orders     = $index->getAttribute('orders', []);
-        $ttl        = $index->getAttribute('ttl', 0);
-        if ($type !== Database::INDEX_TTL) {
+        if ($type !== IndexType::Ttl) {
             return true;
         }
 
-        if (count($attributes) !== 1) {
+        if (count($index->attributes) !== 1) {
             $this->message = 'TTL indexes must be created on a single datetime attribute.';
+
             return false;
         }
 
-        $attributeName = $attributes[0] ?? '';
-        $attribute     = $this->attributes[\strtolower($attributeName)] ?? new Document();
-        $attributeType = $attribute->getAttribute('type', '');
+        $attributeName = (string) ($index->attributes[0] ?? '');
+        $attribute = $this->attributes[\strtolower($attributeName)] ?? new AttributeVO();
+        $attributeType = $attribute->type;
+
+        if ($this->supportForAttributes && $attributeType !== ColumnType::Datetime) {
+            $this->message = 'TTL index can only be created on datetime attributes. Attribute "'.$attributeName.'" is of type "'.$attributeType->value.'"';
 
-        if ($this->supportForAttributes && $attributeType !== Database::VAR_DATETIME) {
-            $this->message = 'TTL index can only be created on datetime attributes. Attribute "' . $attributeName . '" is of type "' . $attributeType . '"';
             return false;
         }
 
-        if ($ttl < 1) {
+        if ($index->ttl < 1) {
             $this->message = 'TTL must be at least 1 second';
+
             return false;
         }
 
         // Check if there's already a TTL index in this collection
         foreach ($this->indexes as $existingIndex) {
-            if ($existingIndex->getId() === $index->getId()) {
+            if ($existingIndex->key === $index->key) {
                 continue;
             }
 
             // Check if existing index is also a TTL index
-            if ($existingIndex->getAttribute('type') === Database::INDEX_TTL) {
+            if ($existingIndex->type === IndexType::Ttl) {
                 $this->message = 'There can be only one TTL index in a collection';
+
                 return false;
             }
         }
@@ -858,6 +917,17 @@ private function isDottedAttribute(string $attribute): bool
 
     private function getBaseAttributeFromDottedAttribute(string $attribute): string
     {
-        return $this->isDottedAttribute($attribute) ? \explode('.', $attribute, 2)[0] ?? '' : $attribute;
+        return $this->isDottedAttribute($attribute) ? \explode('.', $attribute, 2)[0] : $attribute;
+    }
+
+    /**
+     * @return array<string|null>
+     */
+    private static function orderValues(IndexVO $index): array
+    {
+        return \array_map(
+            static fn (?Order $order): ?string => $order?->value,
+            $index->orders,
+        );
     }
 }
diff --git a/src/Database/Validator/IndexDependency.php b/src/Database/Validator/IndexDependency.php
index 7e8453b830..1d218a4936 100644
--- a/src/Database/Validator/IndexDependency.php
+++ b/src/Database/Validator/IndexDependency.php
@@ -2,9 +2,14 @@
 
 namespace Utopia\Database\Validator;
 
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Document;
+use Utopia\Database\Index as IndexVO;
 use Utopia\Validator;
 
+/**
+ * Validates that an attribute can be safely deleted or renamed by checking for index dependencies.
+ */
 class IndexDependency extends Validator
 {
     protected string $message = "Attribute can't be deleted or renamed because it is used in an index";
@@ -12,18 +17,20 @@ class IndexDependency extends Validator
     protected bool $castIndexSupport;
 
     /**
-     * @var array<Document>
+     * @var array<IndexVO>
      */
     protected array $indexes;
 
     /**
-     * @param array<Document> $indexes
-     * @param bool $castIndexSupport
+     * @param  array<IndexVO|Document>  $indexes
      */
     public function __construct(array $indexes, bool $castIndexSupport)
     {
         $this->castIndexSupport = $castIndexSupport;
-        $this->indexes = $indexes;
+        $this->indexes = [];
+        foreach ($indexes as $index) {
+            $this->indexes[] = $index instanceof IndexVO ? $index : IndexVO::fromDocument($index);
+        }
     }
 
     /**
@@ -37,7 +44,7 @@ public function getDescription(): string
     /**
      * Is valid.
      *
-     * @param  Document  $value
+     * @param  AttributeVO|Document  $value
      */
     public function isValid($value): bool
     {
@@ -45,15 +52,16 @@ public function isValid($value): bool
             return true;
         }
 
-        if (! $value->getAttribute('array', false)) {
+        $attr = $value instanceof AttributeVO ? $value : AttributeVO::fromDocument($value);
+
+        if (! $attr->array) {
             return true;
         }
 
-        $key = \strtolower($value->getAttribute('key', $value->getAttribute('$id')));
+        $key = \strtolower($attr->key);
 
         foreach ($this->indexes as $index) {
-            $attributes = $index->getAttribute('attributes', []);
-            foreach ($attributes as $attribute) {
+            foreach ($index->attributes as $attribute) {
                 if ($key === \strtolower($attribute)) {
                     return false;
                 }
diff --git a/src/Database/Validator/IndexedQueries.php b/src/Database/Validator/IndexedQueries.php
index a24e0d21da..04bc79dcd1 100644
--- a/src/Database/Validator/IndexedQueries.php
+++ b/src/Database/Validator/IndexedQueries.php
@@ -3,20 +3,34 @@
 namespace Utopia\Database\Validator;
 
 use Exception;
-use Utopia\Database\Database;
+use Throwable;
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Document;
+use Utopia\Database\Index as IndexVO;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Base;
+use Utopia\Query\Method;
+use Utopia\Query\Query as BaseQuery;
+use Utopia\Query\Schema\IndexType;
 
+/**
+ * Validates queries against available indexes, ensuring search queries have matching fulltext indexes.
+ */
 class IndexedQueries extends Queries
 {
+    private const string UID_INDEX = '_uid_';
+
+    private const string CREATED_AT_INDEX = '_created_at_';
+
+    private const string UPDATED_AT_INDEX = '_updated_at_';
+
     /**
-     * @var array<Document>
+     * @var array<AttributeVO>
      */
     protected array $attributes = [];
 
     /**
-     * @var array<Document>
+     * @var array<IndexVO>
      */
     protected array $indexes = [];
 
@@ -25,32 +39,24 @@ class IndexedQueries extends Queries
      *
      * This Queries Validator filters indexes for only available indexes
      *
-     * @param array<Document> $attributes
-     * @param array<Document> $indexes
-     * @param array<Base> $validators
+     * @param  array<AttributeVO|Document>  $attributes
+     * @param  array<IndexVO|Document>  $indexes
+     * @param  array<Base>  $validators
+     *
      * @throws Exception
      */
     public function __construct(array $attributes = [], array $indexes = [], array $validators = [])
     {
-        $this->attributes = $attributes;
-
-        $this->indexes[] = new Document([
-            'type' => Database::INDEX_UNIQUE,
-            'attributes' => ['$id']
-        ]);
-
-        $this->indexes[] = new Document([
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['$createdAt']
-        ]);
+        foreach ($attributes as $attribute) {
+            $this->attributes[] = $attribute instanceof AttributeVO ? $attribute : AttributeVO::fromDocument($attribute);
+        }
 
-        $this->indexes[] = new Document([
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['$updatedAt']
-        ]);
+        $this->indexes[] = new IndexVO(key: self::UID_INDEX, type: IndexType::Unique, attributes: [Document::ID]);
+        $this->indexes[] = new IndexVO(key: self::CREATED_AT_INDEX, type: IndexType::Key, attributes: [Document::CREATED_AT]);
+        $this->indexes[] = new IndexVO(key: self::UPDATED_AT_INDEX, type: IndexType::Key, attributes: [Document::UPDATED_AT]);
 
         foreach ($indexes as $index) {
-            $this->indexes[] = $index;
+            $this->indexes[] = $index instanceof IndexVO ? $index : IndexVO::fromDocument($index);
         }
 
         parent::__construct($validators);
@@ -59,20 +65,23 @@ public function __construct(array $attributes = [], array $indexes = [], array $
     /**
      * Count vector queries across entire query tree
      *
-     * @param array<Query> $queries
-     * @return int
+     * @param  array<BaseQuery>  $queries
      */
     private function countVectorQueries(array $queries): int
     {
         $count = 0;
 
         foreach ($queries as $query) {
-            if (in_array($query->getMethod(), Query::VECTOR_TYPES)) {
+            if (in_array($query->getMethod(), [Method::VectorDot, Method::VectorCosine, Method::VectorEuclidean])) {
                 $count++;
             }
 
-            if ($query->isNested()) {
-                $count += $this->countVectorQueries($query->getValues());
+            if ($query->isNestedJoin()) {
+                $count += $this->countVectorQueries($query->getJoinOnQueries());
+            } elseif ($query->isNested()) {
+                /** @var array<BaseQuery> $nestedValues */
+                $nestedValues = $query->getValues();
+                $count += $this->countVectorQueries($nestedValues);
             }
         }
 
@@ -80,63 +89,106 @@ private function countVectorQueries(array $queries): int
     }
 
     /**
-     * @param mixed $value
-     * @return bool
+     * @param  array<BaseQuery>  $queries
+     * @return array<string, true>
+     */
+    private function joinAliases(array $queries): array
+    {
+        $aliases = [];
+
+        foreach ($queries as $query) {
+            if (! $query->getMethod()->isJoin()) {
+                continue;
+            }
+
+            $alias = $query->getJoinAlias();
+            if ($alias !== '') {
+                $aliases[$alias] = true;
+            }
+        }
+
+        return $aliases;
+    }
+
+    /**
+     * @param  mixed  $value
+     *
      * @throws Exception
      */
     public function isValid($value): bool
     {
-        if (!parent::isValid($value)) {
+        /** @var array<Query|string> $value */
+        if (! parent::isValid($value)) {
             return false;
         }
         $queries = [];
         foreach ($value as $query) {
             if (! $query instanceof Query) {
                 try {
-                    $query = Query::parse($query);
-                } catch (\Throwable $e) {
+                    $query = Query::parse((string) $query);
+                } catch (Throwable $e) {
                     $this->message = 'Invalid query: '.$e->getMessage();
 
                     return false;
                 }
             }
 
-            if ($query->isNested()) {
-                if (! self::isValid($query->getValues())) {
-                    return false;
-                }
-            }
-
             $queries[] = $query;
         }
 
         $vectorQueryCount = $this->countVectorQueries($queries);
         if ($vectorQueryCount > 1) {
             $this->message = 'Cannot use multiple vector queries in a single request';
+
             return false;
         }
 
-        $grouped = Query::groupByType($queries);
-        $filters = $grouped['filters'];
+        return $this->validateSearchIndexes($queries, $this->joinAliases($queries));
+    }
 
-        foreach ($filters as $filter) {
+    /**
+     * @param  array<BaseQuery>  $queries
+     * @param  array<string, true>  $joinAliases
+     */
+    private function validateSearchIndexes(array $queries, array $joinAliases): bool
+    {
+        foreach ($queries as $query) {
             if (
-                $filter->getMethod() === Query::TYPE_SEARCH ||
-                $filter->getMethod() === Query::TYPE_NOT_SEARCH
+                $query->getMethod() === Method::Search ||
+                $query->getMethod() === Method::NotSearch
             ) {
+                $attribute = $query->getAttribute();
+                $dot = \strpos($attribute, '.');
+                if ($dot !== false && isset($joinAliases[\substr($attribute, 0, $dot)])) {
+                    continue;
+                }
+
                 $matched = false;
 
                 foreach ($this->indexes as $index) {
                     if (
-                        $index->getAttribute('type') === Database::INDEX_FULLTEXT
-                        && $index->getAttribute('attributes') === [$filter->getAttribute()]
+                        $index->type === IndexType::Fulltext
+                        && $index->attributes === [$attribute]
                     ) {
                         $matched = true;
                     }
                 }
 
-                if (!$matched) {
-                    $this->message = "Searching by attribute \"{$filter->getAttribute()}\" requires a fulltext index.";
+                if (! $matched) {
+                    $this->message = "Searching by attribute \"{$attribute}\" requires a fulltext index.";
+
+                    return false;
+                }
+            }
+
+            if ($query->isNestedJoin()) {
+                if (! $this->validateSearchIndexes($query->getJoinOnQueries(), $joinAliases)) {
+                    return false;
+                }
+            } elseif ($query->isNested() && $query->getMethod() !== Method::Having) {
+                /** @var array<BaseQuery> $nested */
+                $nested = $query->getValues();
+                if (! $this->validateSearchIndexes($nested, $joinAliases)) {
                     return false;
                 }
             }
diff --git a/src/Database/Validator/Key.php b/src/Database/Validator/Key.php
index 8434446777..bfebfdf27a 100644
--- a/src/Database/Validator/Key.php
+++ b/src/Database/Validator/Key.php
@@ -3,8 +3,12 @@
 namespace Utopia\Database\Validator;
 
 use Utopia\Database\Database;
+use Utopia\Database\Document;
 use Utopia\Validator;
 
+/**
+ * Validates key strings ensuring they contain only alphanumeric chars, periods, hyphens, and underscores.
+ */
 class Key extends Validator
 {
     protected string $message;
@@ -13,8 +17,6 @@ class Key extends Validator
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -28,20 +30,17 @@ public function __construct(
         protected readonly bool $allowInternal = false,
         protected readonly int $maxLength = Database::MAX_UID_DEFAULT_LENGTH,
     ) {
-        $this->message = 'Parameter must contain at most ' . $this->maxLength . ' chars. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can\'t start with a special char';
+        $this->message = 'Parameter must contain at most '.$this->maxLength.' chars. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can\'t start with a special char';
     }
 
     /**
      * Is valid.
      *
      * Returns true if valid or false if not.
-     *
-     * @param $value
-     * @return bool
      */
     public function isValid($value): bool
     {
-        if (!\is_string($value)) {
+        if (! \is_string($value)) {
             return false;
         }
 
@@ -57,12 +56,12 @@ public function isValid($value): bool
 
         $isInternal = $leading === '$';
 
-        if ($isInternal && !$this->allowInternal) {
+        if ($isInternal && ! $this->allowInternal) {
             return false;
         }
 
         if ($isInternal) {
-            $allowList = [ '$id', '$createdAt', '$updatedAt' ];
+            $allowList = [Document::ID, Document::CREATED_AT, Document::UPDATED_AT];
 
             // If exact match, no need for any further checks
             return \in_array($value, $allowList);
@@ -85,8 +84,6 @@ public function isValid($value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -97,8 +94,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Label.php b/src/Database/Validator/Label.php
index cf09be0b19..29ff3ab6e5 100644
--- a/src/Database/Validator/Label.php
+++ b/src/Database/Validator/Label.php
@@ -4,28 +4,37 @@
 
 use Utopia\Database\Database;
 
+/**
+ * Validates label strings ensuring they contain only alphanumeric characters.
+ */
 class Label extends Key
 {
+    /**
+     * Create a new label validator.
+     *
+     * @param bool $allowInternal Whether to allow internal attribute names starting with $
+     * @param int $maxLength Maximum allowed string length
+     */
     public function __construct(
         bool $allowInternal = false,
         int $maxLength = Database::MAX_UID_DEFAULT_LENGTH
     ) {
         parent::__construct($allowInternal, $maxLength);
-        $this->message = 'Value must be a valid string between 1 and ' . $this->maxLength . ' chars containing only alphanumeric chars';
+        $this->message = 'Value must be a valid string between 1 and '.$this->maxLength.' chars containing only alphanumeric chars';
     }
 
     /**
      * Is valid.
      *
      * Returns true if valid or false if not.
-     *
-     * @param $value
-     *
-     * @return bool
      */
     public function isValid($value): bool
     {
-        if (!parent::isValid($value)) {
+        if (! parent::isValid($value)) {
+            return false;
+        }
+
+        if (! \is_string($value)) {
             return false;
         }
 
diff --git a/src/Database/Validator/ObjectValidator.php b/src/Database/Validator/ObjectValidator.php
index 1103128010..329d2184f5 100644
--- a/src/Database/Validator/ObjectValidator.php
+++ b/src/Database/Validator/ObjectValidator.php
@@ -4,6 +4,9 @@
 
 use Utopia\Validator;
 
+/**
+ * Validates that a value is a valid object (associative array or valid JSON string).
+ */
 class ObjectValidator extends Validator
 {
     /**
@@ -16,23 +19,24 @@ public function getDescription(): string
 
     /**
      * Is Valid
-     *
-     * @param mixed $value
      */
     public function isValid(mixed $value): bool
     {
         if (is_string($value)) {
-            // Check if it's valid JSON
-            json_decode($value);
-            return json_last_error() === JSON_ERROR_NONE;
+            $decoded = json_decode($value);
+
+            if (json_last_error() !== JSON_ERROR_NONE) {
+                return false;
+            }
+
+            $value = $decoded;
         }
 
         if ($value instanceof \stdClass) {
             return true;
         }
 
-        // Allow empty or associative arrays (non-list)
-        return empty($value) || (is_array($value) && !array_is_list($value));
+        return is_array($value) && (count($value) === 0 || ! array_is_list($value));
     }
 
     /**
diff --git a/src/Database/Validator/Operator.php b/src/Database/Validator/Operator.php
index 655d5d511d..0b8193720b 100644
--- a/src/Database/Validator/Operator.php
+++ b/src/Database/Validator/Operator.php
@@ -2,17 +2,25 @@
 
 namespace Utopia\Database\Validator;
 
-use Utopia\Database\Database;
+use Throwable;
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Document;
 use Utopia\Database\Operator as DatabaseOperator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator;
 
+/**
+ * Validates update operators (increment, append, toggle, etc.) against collection attribute types and constraints.
+ */
 class Operator extends Validator
 {
     protected Document $collection;
 
     /**
-     * @var array<string, Document|array<string, mixed>>
+     * @var array<string, AttributeVO>
      */
     protected array $attributes = [];
 
@@ -23,24 +31,26 @@ class Operator extends Validator
     /**
      * Constructor
      *
-     * @param Document $collection
-     * @param Document|null $currentDocument Current document for runtime validation (e.g., array bounds checking)
+     * @param  Document|null  $currentDocument  Current document for runtime validation (e.g., array bounds checking)
      */
-    public function __construct(Document $collection, ?Document $currentDocument = null)
-    {
+    public function __construct(
+        Document $collection,
+        ?Document $currentDocument = null,
+        private readonly bool $supportUnsignedBigInt = true,
+    ) {
         $this->collection = $collection;
         $this->currentDocument = $currentDocument;
 
-        foreach ($collection->getAttribute('attributes', []) as $attribute) {
-            $this->attributes[$attribute->getAttribute('key', $attribute->getId())] = $attribute;
+        /** @var array<AttributeVO|Document> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        foreach ($collectionAttributes as $attribute) {
+            $typed = $attribute instanceof AttributeVO ? $attribute : AttributeVO::fromDocument($attribute);
+            $this->attributes[$typed->key] = $typed;
         }
     }
 
     /**
      * Check if a value is a valid relationship reference (string ID or Document)
-     *
-     * @param mixed $item
-     * @return bool
      */
     private function isValidRelationshipValue(mixed $item): bool
     {
@@ -49,43 +59,136 @@ private function isValidRelationshipValue(mixed $item): bool
 
     /**
      * Check if a relationship attribute represents a "many" side (returns array of documents)
-     *
-     * @param Document|array<string, mixed> $attribute
-     * @return bool
      */
-    private function isRelationshipArray(Document|array $attribute): bool
+    private function isRelationshipArray(AttributeVO $attribute): bool
     {
-        $options = $attribute instanceof Document
-            ? $attribute->getAttribute('options', [])
-            : ($attribute['options'] ?? []);
+        $options = $attribute->options ?? [];
+
+        /** @var array<string, mixed> $options */
 
-        $relationType = $options['relationType'] ?? '';
-        $side = $options['side'] ?? '';
+        $relationTypeRaw = $options['relationType'] ?? '';
+        $sideRaw = $options['side'] ?? '';
+
+        $relationType = $relationTypeRaw instanceof RelationType
+            ? $relationTypeRaw
+            : (\is_string($relationTypeRaw) && $relationTypeRaw !== '' ? RelationType::from($relationTypeRaw) : null);
+        $side = $sideRaw instanceof RelationSide
+            ? $sideRaw
+            : (\is_string($sideRaw) && $sideRaw !== '' ? RelationSide::from($sideRaw) : null);
 
         // Many-to-many is always an array on both sides
-        if ($relationType === Database::RELATION_MANY_TO_MANY) {
+        if ($relationType === RelationType::ManyToMany) {
             return true;
         }
 
         // One-to-many: array on parent side, single on child side
-        if ($relationType === Database::RELATION_ONE_TO_MANY && $side === Database::RELATION_SIDE_PARENT) {
+        if ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) {
             return true;
         }
 
         // Many-to-one: array on child side, single on parent side
-        if ($relationType === Database::RELATION_MANY_TO_ONE && $side === Database::RELATION_SIDE_CHILD) {
+        if ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) {
             return true;
         }
 
         return false;
     }
 
+    /**
+     * @return array{min: int|float|string, max: int|float|string}|null
+     */
+    private function getNumericBounds(AttributeVO $attribute): ?array
+    {
+        return AttributeVO::getNumericBounds($attribute->type, $attribute->signed);
+    }
+
+    private function isNumericValueInBounds(mixed $value, AttributeVO $attribute): bool
+    {
+        $bounds = $this->getNumericBounds($attribute);
+        if ($bounds === null) {
+            return false;
+        }
+
+        if (AttributeVO::isIntegerType($attribute->type)) {
+            $integer = $this->getIntegerValue($value);
+
+            return $integer !== null
+                && BigInt::compare($integer, $bounds['min']) >= 0
+                && BigInt::compare($integer, $bounds['max']) <= 0;
+        }
+
+        $numeric = $this->getNumericValue($value);
+        if ($numeric === null) {
+            return false;
+        }
+
+        if (\is_float($numeric) && ! \is_finite($numeric)) {
+            return false;
+        }
+
+        return $numeric >= $bounds['min'] && $numeric <= $bounds['max'];
+    }
+
+    private function getIntegerValue(mixed $value): int|string|null
+    {
+        if (\is_int($value)) {
+            return $value;
+        }
+        if (\is_string($value) && BigInt::isIntegerString($value)) {
+            return BigInt::toNative($value);
+        }
+        if (\is_float($value) && \is_finite($value) && \floor($value) === $value && $value >= \PHP_INT_MIN && $value <= \PHP_INT_MAX) {
+            return (int) $value;
+        }
+
+        return null;
+    }
+
+    private function getNumericValue(mixed $value): int|float|null
+    {
+        if (\is_int($value) || \is_float($value)) {
+            return $value;
+        }
+
+        if (! \is_string($value) || ! \is_numeric($value)) {
+            return null;
+        }
+
+        return BigInt::fitsPhpInt($value) ? (int) $value : (float) $value;
+    }
+
+    private function setNumericRangeMessage(OperatorType $method, AttributeVO $attribute, int|float|string $result): bool
+    {
+        $bounds = $this->getNumericBounds($attribute);
+        if ($bounds === null) {
+            return false;
+        }
+
+        $aboveMaximum = AttributeVO::isIntegerType($attribute->type)
+            ? BigInt::compare($result, $bounds['max']) > 0
+            : $result > $bounds['max'];
+        if ($aboveMaximum) {
+            $this->message = "Cannot apply {$method->value} operator: would overflow maximum value of {$bounds['max']}";
+
+            return false;
+        }
+
+        $belowMinimum = AttributeVO::isIntegerType($attribute->type)
+            ? BigInt::compare($result, $bounds['min']) < 0
+            : $result < $bounds['min'];
+        if ($belowMinimum) {
+            $this->message = "Cannot apply {$method->value} operator: would underflow minimum value of {$bounds['min']}";
+
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Get Description
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -96,18 +199,17 @@ public function getDescription(): string
      * Is valid
      *
      * Returns true if valid or false if not.
-     *
-     * @param $value
-     *
-     * @return bool
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof DatabaseOperator) {
+        if (! $value instanceof DatabaseOperator) {
             try {
-                $value = DatabaseOperator::parse($value);
-            } catch (\Throwable $e) {
-                $this->message = 'Invalid operator: ' . $e->getMessage();
+                /** @var string $valueStr */
+                $valueStr = $value;
+                $value = DatabaseOperator::parse($valueStr);
+            } catch (Throwable $e) {
+                $this->message = 'Invalid operator: '.$e->getMessage();
+
                 return false;
             }
         }
@@ -115,16 +217,11 @@ public function isValid($value): bool
         $method = $value->getMethod();
         $attribute = $value->getAttribute();
 
-        // Check if method is valid
-        if (!DatabaseOperator::isMethod($method)) {
-            $this->message = "Invalid operator method: {$method}";
-            return false;
-        }
-
         // Check if attribute exists in collection
         $attributeConfig = $this->attributes[$attribute] ?? null;
         if ($attributeConfig === null) {
             $this->message = "Attribute '{$attribute}' does not exist in collection";
+
             return false;
         }
 
@@ -134,21 +231,17 @@ public function isValid($value): bool
 
     /**
      * Validate operator against attribute configuration
-     *
-     * @param DatabaseOperator $operator
-     * @param Document|array<string, mixed> $attribute
-     * @return bool
      */
     private function validateOperatorForAttribute(
         DatabaseOperator $operator,
-        Document|array $attribute
+        AttributeVO $attribute
     ): bool {
         $method = $operator->getMethod();
+        $methodName = $method->value;
         $values = $operator->getValues();
 
-        // Handle both Document objects and arrays
-        $type = $attribute instanceof Document ? $attribute->getAttribute('type') : $attribute['type'];
-        $isArray = $attribute instanceof Document ? ($attribute->getAttribute('array') ?? false) : ($attribute['array'] ?? false);
+        $type = $attribute->type;
+        $isArray = $attribute->array;
 
         // Array operators that carry a caller-supplied value list are capped to guard against
         // memory exhaustion. Enforced here so every adapter rejects an oversized list the same way.
@@ -156,11 +249,11 @@ private function validateOperatorForAttribute(
         // operators normalize with), so measure whichever the operator will actually process.
         if (
             \in_array($method, [
-                DatabaseOperator::TYPE_ARRAY_APPEND,
-                DatabaseOperator::TYPE_ARRAY_PREPEND,
-                DatabaseOperator::TYPE_ARRAY_INTERSECT,
-                DatabaseOperator::TYPE_ARRAY_DIFF,
-                DatabaseOperator::TYPE_ARRAY_REMOVE,
+                OperatorType::ArrayAppend,
+                OperatorType::ArrayPrepend,
+                OperatorType::ArrayIntersect,
+                OperatorType::ArrayDiff,
+                OperatorType::ArrayRemove,
             ], true)
         ) {
             $payload = (isset($values[0]) && \is_array($values[0])) ? $values[0] : $values;
@@ -171,138 +264,175 @@ private function validateOperatorForAttribute(
         }
 
         switch ($method) {
-            case DatabaseOperator::TYPE_INCREMENT:
-            case DatabaseOperator::TYPE_DECREMENT:
-            case DatabaseOperator::TYPE_MULTIPLY:
-            case DatabaseOperator::TYPE_DIVIDE:
-            case DatabaseOperator::TYPE_MODULO:
-            case DatabaseOperator::TYPE_POWER:
+            case OperatorType::Increment:
+            case OperatorType::Decrement:
+            case OperatorType::Multiply:
+            case OperatorType::Divide:
+            case OperatorType::Modulo:
+            case OperatorType::Power:
                 // Numeric operations only work on numeric types
-                if (!\in_array($type, [Database::VAR_INTEGER, Database::VAR_FLOAT])) {
-                    $this->message = "Cannot apply {$method} operator to non-numeric field '{$operator->getAttribute()}'";
+                if (! AttributeVO::isNumericType($type)) {
+                    $this->message = "Cannot apply {$methodName} operator to non-numeric field '{$operator->getAttribute()}'";
+
+                    return false;
+                }
+
+                if (! $attribute->signed
+                    && \in_array($type, [ColumnType::BigInteger, ColumnType::BigSerial], true)
+                    && ! $this->supportUnsignedBigInt) {
+                    $this->message = "Cannot apply {$methodName} operator: unsigned 64-bit arithmetic is not supported by this adapter";
+
                     return false;
                 }
 
                 // Validate the numeric value and optional max/min
-                if (!isset($values[0]) || !\is_numeric($values[0])) {
-                    $this->message = "Cannot apply {$method} operator: value must be numeric, got " . gettype($operator->getValue());
+                if (! isset($values[0]) || ! $this->isNumericValueInBounds($values[0], $attribute)) {
+                    $this->message = "Cannot apply {$methodName} operator: value must be numeric, got ".gettype($operator->getValue());
+
                     return false;
                 }
 
                 // Special validation for divide/modulo by zero
-                if (($method === DatabaseOperator::TYPE_DIVIDE || $method === DatabaseOperator::TYPE_MODULO) && (float)$values[0] === 0.0) {
-                    $this->message = "Cannot apply {$method} operator: " . ($method === DatabaseOperator::TYPE_DIVIDE ? "division" : "modulo") . " by zero";
+                $integerType = AttributeVO::isIntegerType($type);
+                $operatorValue = $integerType
+                    ? $this->getIntegerValue($values[0])
+                    : $this->getNumericValue($values[0]);
+                if ($operatorValue === null) {
+                    return false;
+                }
+
+                if (($method === OperatorType::Divide || $method === OperatorType::Modulo) && ($operatorValue === 0 || $operatorValue === 0.0)) {
+                    $this->message = "Cannot apply {$methodName} operator: ".($method === OperatorType::Divide ? 'division' : 'modulo').' by zero';
+
                     return false;
                 }
 
                 // Validate max/min if provided
-                if (\count($values) > 1 && $values[1] !== null && !\is_numeric($values[1])) {
-                    $this->message = "Cannot apply {$method} operator: max/min limit must be numeric, got " . \gettype($values[1]);
+                if (\count($values) > 1 && $values[1] !== null && ! $this->isNumericValueInBounds($values[1], $attribute)) {
+                    $this->message = "Cannot apply {$methodName} operator: max/min limit must be numeric, got ".\gettype($values[1]);
+
                     return false;
                 }
 
-                if ($this->currentDocument !== null && $type === Database::VAR_INTEGER && !isset($values[1])) {
-                    $currentValue = $this->currentDocument->getAttribute($operator->getAttribute()) ?? 0;
-                    $operatorValue = $values[0];
+                if ($this->currentDocument !== null && $integerType && ! isset($values[1])) {
+                    $currentValue = $this->getIntegerValue($this->currentDocument->getAttribute($operator->getAttribute()) ?? 0);
+
+                    if ($currentValue === null || ! $this->isNumericValueInBounds($currentValue, $attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator: current value is outside the attribute range";
+
+                        return false;
+                    }
 
-                    // Compute predicted result
-                    $predictedResult = match ($method) {
-                        DatabaseOperator::TYPE_INCREMENT => $currentValue + $operatorValue,
-                        DatabaseOperator::TYPE_DECREMENT => $currentValue - $operatorValue,
-                        DatabaseOperator::TYPE_MULTIPLY => $currentValue * $operatorValue,
-                        DatabaseOperator::TYPE_DIVIDE => $currentValue / $operatorValue,
-                        DatabaseOperator::TYPE_MODULO => $currentValue % $operatorValue,
-                        DatabaseOperator::TYPE_POWER => $currentValue ** $operatorValue,
-                    };
+                    try {
+                        $predictedResult = BigInt::calculate($method, $currentValue, $operatorValue);
+                    } catch (\InvalidArgumentException) {
+                        $this->message = "Cannot apply {$methodName} operator: result is outside the attribute range";
 
-                    if ($predictedResult > Database::MAX_INT) {
-                        $this->message = "Cannot apply {$method} operator: would overflow maximum value of " . Database::MAX_INT;
                         return false;
                     }
 
-                    if ($predictedResult < Database::MIN_INT) {
-                        $this->message = "Cannot apply {$method} operator: would underflow minimum value of " . Database::MIN_INT;
+                    if (! $this->setNumericRangeMessage($method, $attribute, $predictedResult)) {
                         return false;
                     }
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_APPEND:
-            case DatabaseOperator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
                 // For relationships, check if it's a "many" side
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
                     foreach ($values as $item) {
-                        if (!$this->isValidRelationshipValue($item)) {
-                            $this->message = "Cannot apply {$method} operator: relationship values must be document IDs (strings) or Document objects";
+                        if (! $this->isValidRelationshipValue($item)) {
+                            $this->message = "Cannot apply {$methodName} operator: relationship values must be document IDs (strings) or Document objects";
+
                             return false;
                         }
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-array field '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-array field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
-                if (!empty($values) && $type === Database::VAR_INTEGER) {
+                if (! empty($values) && AttributeVO::isIntegerType($type)) {
                     $newItems = \is_array($values[0]) ? $values[0] : $values;
                     foreach ($newItems as $item) {
-                        if (\is_numeric($item) && ($item > Database::MAX_INT || $item < Database::MIN_INT)) {
-                            $this->message = "Cannot apply {$method} operator: array items must be between " . Database::MIN_INT . " and " . Database::MAX_INT;
+                        if (\is_numeric($item) && ! $this->isNumericValueInBounds($item, $attribute)) {
+                            $bounds = $this->getNumericBounds($attribute);
+                            if ($bounds === null) {
+                                return false;
+                            }
+                            $this->message = "Cannot apply {$methodName} operator: array items must be between {$bounds['min']} and {$bounds['max']}";
+
                             return false;
                         }
                     }
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_UNIQUE:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayUnique:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-array field '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-array field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_INSERT:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayInsert:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-array field '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-array field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 if (\count($values) !== 2) {
-                    $this->message = "Cannot apply {$method} operator: requires exactly 2 values (index and value)";
+                    $this->message = "Cannot apply {$methodName} operator: requires exactly 2 values (index and value)";
+
                     return false;
                 }
 
                 $index = $values[0];
-                if (!\is_int($index) || $index < 0) {
-                    $this->message = "Cannot apply {$method} operator: index must be a non-negative integer";
+                if (! \is_int($index) || $index < 0) {
+                    $this->message = "Cannot apply {$methodName} operator: index must be a non-negative integer";
+
                     return false;
                 }
 
                 $insertValue = $values[1];
 
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isValidRelationshipValue($insertValue)) {
-                        $this->message = "Cannot apply {$method} operator: relationship values must be document IDs (strings) or Document objects";
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isValidRelationshipValue($insertValue)) {
+                        $this->message = "Cannot apply {$methodName} operator: relationship values must be document IDs (strings) or Document objects";
+
                         return false;
                     }
                 }
 
-                if ($type === Database::VAR_INTEGER && \is_numeric($insertValue)) {
-                    if ($insertValue > Database::MAX_INT || $insertValue < Database::MIN_INT) {
-                        $this->message = "Cannot apply {$method} operator: array items must be between " . Database::MIN_INT . " and " . Database::MAX_INT;
+                if (AttributeVO::isIntegerType($type) && \is_numeric($insertValue)) {
+                    if (! $this->isNumericValueInBounds($insertValue, $attribute)) {
+                        $bounds = $this->getNumericBounds($attribute);
+                        if ($bounds === null) {
+                            return false;
+                        }
+                        $this->message = "Cannot apply {$methodName} operator: array items must be between {$bounds['min']} and {$bounds['max']}";
+
                         return false;
                     }
                 }
@@ -314,179 +444,201 @@ private function validateOperatorForAttribute(
                         $arrayLength = \count($currentArray);
                         // Valid indices are 0 to length (inclusive, as we can append)
                         if ($index > $arrayLength) {
-                            $this->message = "Cannot apply {$method} operator: index {$index} is out of bounds for array of length {$arrayLength}";
+                            $this->message = "Cannot apply {$methodName} operator: index {$index} is out of bounds for array of length {$arrayLength}";
+
                             return false;
                         }
                     }
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_REMOVE:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayRemove:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
                     $toValidate = \is_array($values[0]) ? $values[0] : $values;
                     foreach ($toValidate as $item) {
-                        if (!$this->isValidRelationshipValue($item)) {
-                            $this->message = "Cannot apply {$method} operator: relationship values must be document IDs (strings) or Document objects";
+                        if (! $this->isValidRelationshipValue($item)) {
+                            $this->message = "Cannot apply {$methodName} operator: relationship values must be document IDs (strings) or Document objects";
+
                             return false;
                         }
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-array field '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-array field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 if (empty($values)) {
-                    $this->message = "Cannot apply {$method} operator: requires a value to remove";
+                    $this->message = "Cannot apply {$methodName} operator: requires a value to remove";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_INTERSECT:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayIntersect:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot use {$method} operator on non-array attribute '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot use {$methodName} operator on non-array attribute '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 if (empty($values)) {
-                    $this->message = "{$method} operator requires a non-empty array value";
+                    $this->message = "{$methodName} operator requires a non-empty array value";
+
                     return false;
                 }
 
-                if ($type === Database::VAR_RELATIONSHIP) {
+                if ($type === ColumnType::Relationship) {
                     foreach ($values as $item) {
-                        if (!$this->isValidRelationshipValue($item)) {
-                            $this->message = "Cannot apply {$method} operator: relationship values must be document IDs (strings) or Document objects";
+                        if (! $this->isValidRelationshipValue($item)) {
+                            $this->message = "Cannot apply {$methodName} operator: relationship values must be document IDs (strings) or Document objects";
+
                             return false;
                         }
                     }
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_DIFF:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayDiff:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
                     foreach ($values as $item) {
-                        if (!$this->isValidRelationshipValue($item)) {
-                            $this->message = "Cannot apply {$method} operator: relationship values must be document IDs (strings) or Document objects";
+                        if (! $this->isValidRelationshipValue($item)) {
+                            $this->message = "Cannot apply {$methodName} operator: relationship values must be document IDs (strings) or Document objects";
+
                             return false;
                         }
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot use {$method} operator on non-array attribute '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot use {$methodName} operator on non-array attribute '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_ARRAY_FILTER:
-                if ($type === Database::VAR_RELATIONSHIP) {
-                    if (!$this->isRelationshipArray($attribute)) {
-                        $this->message = "Cannot apply {$method} operator to single-value relationship '{$operator->getAttribute()}'";
+            case OperatorType::ArrayFilter:
+                if ($type === ColumnType::Relationship) {
+                    if (! $this->isRelationshipArray($attribute)) {
+                        $this->message = "Cannot apply {$methodName} operator to single-value relationship '{$operator->getAttribute()}'";
+
                         return false;
                     }
-                } elseif (!$isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-array field '{$operator->getAttribute()}'";
+                } elseif (! $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-array field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 if (\count($values) < 1 || \count($values) > 2) {
-                    $this->message = "Cannot apply {$method} operator: requires 1 or 2 values (condition and optional comparison value)";
+                    $this->message = "Cannot apply {$methodName} operator: requires 1 or 2 values (condition and optional comparison value)";
+
                     return false;
                 }
 
-                if (!\is_string($values[0])) {
-                    $this->message = "Cannot apply {$method} operator: condition must be a string";
+                if (! \is_string($values[0])) {
+                    $this->message = "Cannot apply {$methodName} operator: condition must be a string";
+
                     return false;
                 }
 
-                if (!\in_array($values[0], DatabaseOperator::ARRAY_FILTER_CONDITIONS, true)) {
-                    $this->message = "Invalid array filter condition '{$values[0]}'. Must be one of: " . \implode(', ', DatabaseOperator::ARRAY_FILTER_CONDITIONS);
+                if (! \in_array($values[0], DatabaseOperator::ARRAY_FILTER_CONDITIONS, true)) {
+                    $this->message = "Invalid array filter condition '{$values[0]}'. Must be one of: ".\implode(', ', DatabaseOperator::ARRAY_FILTER_CONDITIONS);
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_STRING_CONCAT:
-                if (!in_array($type, Database::STRING_TYPES) || $isArray) {
-                    $this->message = "Cannot apply {$method} operator to non-string field '{$operator->getAttribute()}'";
+            case OperatorType::StringConcat:
+                if (! \in_array($type, [ColumnType::String, ColumnType::Varchar, ColumnType::Text, ColumnType::MediumText, ColumnType::LongText]) || $isArray) {
+                    $this->message = "Cannot apply {$methodName} operator to non-string field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
-                if (empty($values) || !\is_string($values[0])) {
-                    $this->message = "Cannot apply {$method} operator: requires a string value";
+                if (empty($values) || ! \is_string($values[0])) {
+                    $this->message = "Cannot apply {$methodName} operator: requires a string value";
+
                     return false;
                 }
 
-                if ($this->currentDocument !== null && in_array($type, Database::STRING_TYPES)) {
+                if ($this->currentDocument !== null && \in_array($type, [ColumnType::String, ColumnType::Varchar, ColumnType::Text, ColumnType::MediumText, ColumnType::LongText])) {
+                    /** @var string $currentString */
                     $currentString = $this->currentDocument->getAttribute($operator->getAttribute()) ?? '';
                     $concatValue = $values[0];
-                    $predictedLength = strlen($currentString) + strlen($concatValue);
+                    $predictedLength = strlen($currentString) + strlen((string) $concatValue);
 
-                    $maxSize = $attribute instanceof Document
-                        ? $attribute->getAttribute('size', 0)
-                        : ($attribute['size'] ?? 0);
+                    $maxSize = $attribute->size;
 
                     if ($maxSize > 0 && $predictedLength > $maxSize) {
-                        $this->message = "Cannot apply {$method} operator: result would exceed maximum length of {$maxSize} characters";
+                        $this->message = "Cannot apply {$methodName} operator: result would exceed maximum length of {$maxSize} characters";
+
                         return false;
                     }
                 }
 
                 break;
-            case DatabaseOperator::TYPE_STRING_REPLACE:
+            case OperatorType::StringReplace:
                 // Replace only works on string types
-                if (!in_array($type, Database::STRING_TYPES)) {
-                    $this->message = "Cannot apply {$method} operator to non-string field '{$operator->getAttribute()}'";
+                if (! \in_array($type, [ColumnType::String, ColumnType::Varchar, ColumnType::Text, ColumnType::MediumText, ColumnType::LongText])) {
+                    $this->message = "Cannot apply {$methodName} operator to non-string field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
-                if (\count($values) !== 2 || !\is_string($values[0]) || !\is_string($values[1])) {
-                    $this->message = "Cannot apply {$method} operator: requires exactly 2 string values (search and replace)";
+                if (\count($values) !== 2 || ! \is_string($values[0]) || ! \is_string($values[1])) {
+                    $this->message = "Cannot apply {$methodName} operator: requires exactly 2 string values (search and replace)";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_TOGGLE:
+            case OperatorType::Toggle:
                 // Toggle only works on boolean types
-                if ($type !== Database::VAR_BOOLEAN) {
-                    $this->message = "Cannot apply {$method} operator to non-boolean field '{$operator->getAttribute()}'";
+                if ($type !== ColumnType::Boolean) {
+                    $this->message = "Cannot apply {$methodName} operator to non-boolean field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_DATE_ADD_DAYS:
-            case DatabaseOperator::TYPE_DATE_SUB_DAYS:
-                if ($type !== Database::VAR_DATETIME) {
-                    $this->message = "Cannot apply {$method} operator to non-datetime field '{$operator->getAttribute()}'";
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                if ($type !== ColumnType::Datetime) {
+                    $this->message = "Cannot apply {$methodName} operator to non-datetime field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
-                if (empty($values) || !\is_int($values[0])) {
-                    $this->message = "Cannot apply {$method} operator: requires an integer number of days";
+                if (empty($values) || ! \is_int($values[0])) {
+                    $this->message = "Cannot apply {$methodName} operator: requires an integer number of days";
+
                     return false;
                 }
 
                 break;
-            case DatabaseOperator::TYPE_DATE_SET_NOW:
-                if ($type !== Database::VAR_DATETIME) {
-                    $this->message = "Cannot apply {$method} operator to non-datetime field '{$operator->getAttribute()}'";
+            case OperatorType::DateSetNow:
+                if ($type !== ColumnType::Datetime) {
+                    $this->message = "Cannot apply {$methodName} operator to non-datetime field '{$operator->getAttribute()}'";
+
                     return false;
                 }
 
                 break;
-            default:
-                $this->message = "Cannot apply {$method} operator: unsupported operator method";
-                return false;
         }
 
         return true;
@@ -496,8 +648,6 @@ private function validateOperatorForAttribute(
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -508,8 +658,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/PartialStructure.php b/src/Database/Validator/PartialStructure.php
index a386a1fa4b..2218235ec6 100644
--- a/src/Database/Validator/PartialStructure.php
+++ b/src/Database/Validator/PartialStructure.php
@@ -5,6 +5,9 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 
+/**
+ * Validates partial document structures, only requiring attributes that are both marked required and present in the document.
+ */
 class PartialStructure extends Structure
 {
     /**
@@ -12,48 +15,53 @@ class PartialStructure extends Structure
      *
      * Returns true if valid or false if not.
      *
-     * @param mixed $document
-     *
-     * @return bool
+     * @param  mixed  $document
      */
     public function isValid($document): bool
     {
-        if (!$document instanceof Document) {
+        if (! $document instanceof Document) {
             $this->message = 'Value must be an instance of Document';
+
             return false;
         }
 
-        if (empty($this->collection->getId()) || Database::METADATA !== $this->collection->getCollection()) {
+        if (empty($this->collection->getId()) || $this->collection->getCollection() !== Database::METADATA) {
             $this->message = 'Collection not found';
+
             return false;
         }
 
         $keys = [];
         $structure = $document->getArrayCopy();
-        $attributes = \array_merge($this->attributes, $this->collection->getAttribute('attributes', []));
+        /** @var array<string, mixed> $collectionAttributes */
+        $collectionAttributes = $this->collection->getAttribute('attributes', []);
+        /** @var array<string, mixed> $attributes */
+        $attributes = \array_merge($this->attributes, $collectionAttributes);
 
         foreach ($attributes as $attribute) {
-            $name = $attribute['$id'] ?? '';
+            /** @var array<string, mixed> $attribute */
+            /** @var string $name */
+            $name = $attribute[Document::ID] ?? '';
             $keys[$name] = $attribute;
         }
-        /**
-         * @var array<string, mixed> $requiredAttributes
-         */
         $requiredAttributes = [];
         foreach ($this->attributes as $attribute) {
-            if ($attribute['required'] === true && $document->offsetExists($attribute['$id'])) {
+            /** @var array<string, mixed> $attribute */
+            /** @var string $attrId */
+            $attrId = $attribute[Document::ID] ?? '';
+            if ($attribute['required'] === true && $document->offsetExists($attrId)) {
                 $requiredAttributes[] = $attribute;
             }
         }
 
-        if (!$this->checkForAllRequiredValues($structure, $requiredAttributes, $keys)) {
+        if (! $this->checkForAllRequiredValues($structure, $requiredAttributes, $keys)) {
             return false;
         }
-        if (!$this->checkForUnknownAttributes($structure, $keys)) {
+        if (! $this->checkForUnknownAttributes($structure, $keys)) {
             return false;
         }
 
-        if (!$this->checkForInvalidAttributeValues($document, $structure, $keys)) {
+        if (! $this->checkForInvalidAttributeValues($document, $structure, $keys)) {
             return false;
         }
 
diff --git a/src/Database/Validator/Permissions.php b/src/Database/Validator/Permissions.php
index 13e7372050..5d08137e1c 100644
--- a/src/Database/Validator/Permissions.php
+++ b/src/Database/Validator/Permissions.php
@@ -2,9 +2,13 @@
 
 namespace Utopia\Database\Validator;
 
-use Utopia\Database\Database;
+use Exception;
 use Utopia\Database\Helpers\Permission;
+use Utopia\Database\PermissionType;
 
+/**
+ * Validates permission strings ensuring they use valid permission types and role formats.
+ */
 class Permissions extends Roles
 {
     protected string $message = 'Permissions Error';
@@ -19,21 +23,19 @@ class Permissions extends Roles
     /**
      * Permissions constructor.
      *
-     * @param int $length maximum amount of permissions. 0 means unlimited.
-     * @param array<string> $allowed allowed permissions. Defaults to all available.
+     * @param  int  $length  maximum amount of permissions. 0 means unlimited.
+     * @param  array<PermissionType>  $allowed  allowed permissions. Defaults to all available.
      */
-    public function __construct(int $length = 0, array $allowed = [...Database::PERMISSIONS, Database::PERMISSION_WRITE])
+    public function __construct(int $length = 0, array $allowed = [PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete, PermissionType::Write])
     {
         $this->length = $length;
-        $this->allowed = $allowed;
+        $this->allowed = \array_map(fn (PermissionType $p) => $p->value, $allowed);
     }
 
     /**
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -45,35 +47,38 @@ public function getDescription(): string
      *
      * Returns true if valid or false if not.
      *
-     * @param mixed $permissions
-     *
-     * @return bool
+     * @param  mixed  $permissions
      */
     public function isValid($permissions): bool
     {
-        if (!\is_array($permissions)) {
+        if (! \is_array($permissions)) {
             $this->message = 'Permissions must be an array of strings.';
+
             return false;
         }
 
         if ($this->length && \count($permissions) > $this->length) {
-            $this->message = 'You can only provide up to ' . $this->length . ' permissions.';
+            $this->message = 'You can only provide up to '.$this->length.' permissions.';
+
             return false;
         }
 
         foreach ($permissions as $permission) {
-            if (!\is_string($permission)) {
+            if (! \is_string($permission)) {
                 $this->message = 'Every permission must be of type string.';
+
                 return false;
             }
 
             if ($permission === '*') {
                 $this->message = 'Wildcard permission "*" has been replaced. Use "any" instead.';
+
                 return false;
             }
 
             if (\str_contains($permission, 'role:')) {
                 $this->message = 'Permissions using the "role:" prefix have been replaced. Use "users", "guests", or "any" instead.';
+
                 return false;
             }
 
@@ -84,15 +89,17 @@ public function isValid($permissions): bool
                     break;
                 }
             }
-            if (!$isAllowed) {
-                $this->message = 'Permission "' . $permission . '" is not allowed. Must be one of: ' . \implode(', ', $this->allowed) . '.';
+            if (! $isAllowed) {
+                $this->message = 'Permission "'.$permission.'" is not allowed. Must be one of: '.\implode(', ', $this->allowed).'.';
+
                 return false;
             }
 
             try {
                 $permission = Permission::parse($permission);
-            } catch (\Exception $e) {
+            } catch (Exception $e) {
                 $this->message = $e->getMessage();
+
                 return false;
             }
 
@@ -100,10 +107,11 @@ public function isValid($permissions): bool
             $identifier = $permission->getIdentifier();
             $dimension = $permission->getDimension();
 
-            if (!$this->isValidRole($role, $identifier, $dimension)) {
+            if (! $this->isValidRole($role, $identifier, $dimension)) {
                 return false;
             }
         }
+
         return true;
     }
 
@@ -111,8 +119,6 @@ public function isValid($permissions): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -123,8 +129,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Queries.php b/src/Database/Validator/Queries.php
index 4f91251828..f34c8b9bf9 100644
--- a/src/Database/Validator/Queries.php
+++ b/src/Database/Validator/Queries.php
@@ -2,15 +2,20 @@
 
 namespace Utopia\Database\Validator;
 
+use Throwable;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Base;
+use Utopia\Database\Validator\Query\Filter;
+use Utopia\Database\Validator\Query\Order;
+use Utopia\Database\Validator\Query\Select;
+use Utopia\Query\Method;
 use Utopia\Validator;
 
+/**
+ * Validates an array of query objects by dispatching each to the appropriate method-type validator.
+ */
 class Queries extends Validator
 {
-    /**
-     * @var string
-     */
     protected string $message = 'Invalid queries';
 
     /**
@@ -18,15 +23,12 @@ class Queries extends Validator
      */
     protected array $validators;
 
-    /**
-     * @var int
-     */
     protected int $length;
 
     /**
      * Queries constructor
      *
-     * @param array<Base> $validators
+     * @param  array<Base>  $validators
      */
     public function __construct(array $validators = [], int $length = 0)
     {
@@ -38,8 +40,6 @@ public function __construct(array $validators = [], int $length = 0)
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -47,105 +47,228 @@ public function getDescription(): string
     }
 
     /**
-     * @param array<Query|string> $value
-     * @return bool
+     * Validate an array of queries, checking each against registered method-type validators.
+     *
+     * @param  mixed  $value  Array of Query objects or query strings
      */
     public function isValid($value): bool
     {
-        if (!is_array($value)) {
+        if (! \is_array($value)) {
             $this->message = 'Queries must be an array';
+
             return false;
         }
-
+        /** @var array<Query|string> $value */
         if ($this->length && \count($value) > $this->length) {
             return false;
         }
 
-        foreach ($value as $query) {
-            if (!$query instanceof Query) {
+        // One pass over the validators: clear aliases left over from a previous
+        // call, and note whether a filter validator is registered. Order
+        // validators persist across requests in pooled / long-lived processes,
+        // so letting aliases accumulate leaks state and lets an unrelated query
+        // order by a stale alias.
+        $hasFilterValidator = false;
+        foreach ($this->validators as $validator) {
+            if ($validator instanceof Order) {
+                $validator->resetAggregationAliases();
+            }
+            if (
+                $validator instanceof Select
+                || $validator instanceof Filter
+                || $validator instanceof Order
+            ) {
+                $validator->resetJoinAliases();
+            }
+            if ($validator->getMethodType() === Base::METHOD_TYPE_FILTER) {
+                $hasFilterValidator = true;
+            }
+        }
+
+        // One pass over the input: parse each raw string, and collect the
+        // aliases the order, select and filter validators have to know about
+        // before dispatch starts. A method can report as both aggregate and
+        // join, so both are tested independently rather than as a chain.
+        /** @var list<Query> $parsedQueries */
+        $parsedQueries = [];
+        /** @var array<string> $aggregationAliases */
+        $aggregationAliases = [];
+        $joinAliases = [];
+        foreach ($value as $q) {
+            if (! $q instanceof Query) {
                 try {
-                    $query = Query::parse($query);
-                } catch (\Throwable $e) {
-                    $this->message = 'Invalid query: ' . $e->getMessage();
+                    $q = Query::parse($q);
+                } catch (Throwable $e) {
+                    $this->message = 'Invalid query: '.$e->getMessage();
+
                     return false;
                 }
             }
 
-            if ($query->isNested()) {
-                if (!self::isValid($query->getValues())) {
-                    return false;
+            $parsedQueries[] = $q;
+
+            $method = $q->getMethod();
+
+            if ($method->isAggregate()) {
+                $alias = $q->getValue('');
+                if (\is_string($alias) && $alias !== '') {
+                    $aggregationAliases[] = $alias;
+                }
+            }
+
+            if ($method->isJoin()) {
+                $alias = $q->getJoinAlias();
+                if ($alias !== '') {
+                    $joinAliases[] = $alias;
+                }
+            }
+        }
+
+        if ($aggregationAliases !== [] || $joinAliases !== []) {
+            foreach ($this->validators as $validator) {
+                if ($aggregationAliases !== [] && $validator instanceof Order) {
+                    $validator->addAggregationAliases($aggregationAliases);
+                }
+                if (
+                    $joinAliases !== []
+                    && (
+                        $validator instanceof Select
+                        || $validator instanceof Filter
+                        || $validator instanceof Order
+                    )
+                ) {
+                    $validator->allowJoinAliases($joinAliases);
+                }
+            }
+        }
+
+        // Same pass: nested and/or children must keep the join aliases collected above.
+        $pending = $parsedQueries;
+        while ($pending !== []) {
+            $query = \array_shift($pending);
+
+            if (\in_array($query->getMethod(), Query::LOGICAL_TYPES, true)) {
+                foreach ($query->getValues() as $nested) {
+                    if (! $nested instanceof Query) {
+                        if (! \is_string($nested)) {
+                            $this->message = 'Invalid query: nested query must be a string';
+
+                            return false;
+                        }
+                        try {
+                            $nested = Query::parse($nested);
+                        } catch (Throwable $e) {
+                            $this->message = 'Invalid query: '.$e->getMessage();
+
+                            return false;
+                        }
+                    }
+                    $pending[] = $nested;
+                }
+            }
+
+            if ($hasFilterValidator && $query->getMethod()->isJoin() && $query->isNestedJoin()) {
+                foreach ($query->getJoinOnQueries() as $onQuery) {
+                    if ($onQuery->getMethod() === Method::On) {
+                        continue;
+                    }
+                    $pending[] = $onQuery;
                 }
             }
 
             $method = $query->getMethod();
-            $methodType = match ($method) {
-                Query::TYPE_SELECT => Base::METHOD_TYPE_SELECT,
-                Query::TYPE_LIMIT => Base::METHOD_TYPE_LIMIT,
-                Query::TYPE_OFFSET => Base::METHOD_TYPE_OFFSET,
-                Query::TYPE_CURSOR_AFTER,
-                Query::TYPE_CURSOR_BEFORE => Base::METHOD_TYPE_CURSOR,
-                Query::TYPE_ORDER_ASC,
-                Query::TYPE_ORDER_DESC,
-                Query::TYPE_ORDER_RANDOM => Base::METHOD_TYPE_ORDER,
-                Query::TYPE_EQUAL,
-                Query::TYPE_NOT_EQUAL,
-                Query::TYPE_LESSER,
-                Query::TYPE_LESSER_EQUAL,
-                Query::TYPE_GREATER,
-                Query::TYPE_GREATER_EQUAL,
-                Query::TYPE_SEARCH,
-                Query::TYPE_NOT_SEARCH,
-                Query::TYPE_IS_NULL,
-                Query::TYPE_IS_NOT_NULL,
-                Query::TYPE_BETWEEN,
-                Query::TYPE_NOT_BETWEEN,
-                Query::TYPE_STARTS_WITH,
-                Query::TYPE_NOT_STARTS_WITH,
-                Query::TYPE_ENDS_WITH,
-                Query::TYPE_NOT_ENDS_WITH,
-                Query::TYPE_CONTAINS,
-                Query::TYPE_CONTAINS_ANY,
-                Query::TYPE_NOT_CONTAINS,
-                Query::TYPE_AND,
-                Query::TYPE_OR,
-                Query::TYPE_CONTAINS_ALL,
-                Query::TYPE_ELEM_MATCH,
-                Query::TYPE_CROSSES,
-                Query::TYPE_NOT_CROSSES,
-                Query::TYPE_DISTANCE_EQUAL,
-                Query::TYPE_DISTANCE_NOT_EQUAL,
-                Query::TYPE_DISTANCE_GREATER_THAN,
-                Query::TYPE_DISTANCE_LESS_THAN,
-                Query::TYPE_INTERSECTS,
-                Query::TYPE_NOT_INTERSECTS,
-                Query::TYPE_OVERLAPS,
-                Query::TYPE_NOT_OVERLAPS,
-                Query::TYPE_TOUCHES,
-                Query::TYPE_NOT_TOUCHES,
-                Query::TYPE_VECTOR_DOT,
-                Query::TYPE_VECTOR_COSINE,
-                Query::TYPE_VECTOR_EUCLIDEAN,
-                Query::TYPE_REGEX,
-                Query::TYPE_EXISTS,
-                Query::TYPE_NOT_EXISTS => Base::METHOD_TYPE_FILTER,
-                default => '',
-            };
+
+            // Route every aggregate method through the single source of truth
+            // on the base enum. Previously this match hand-listed only half
+            // of the aggregate methods, silently rejecting stddevPop, varPop,
+            // bitAnd, etc. with "Invalid query method".
+            if ($method->isAggregate()) {
+                $methodType = Base::METHOD_TYPE_AGGREGATE;
+            } else {
+                $methodType = match ($method) {
+                    Method::Select => Base::METHOD_TYPE_SELECT,
+                    Method::Limit => Base::METHOD_TYPE_LIMIT,
+                    Method::Offset => Base::METHOD_TYPE_OFFSET,
+                    Method::CursorAfter,
+                    Method::CursorBefore => Base::METHOD_TYPE_CURSOR,
+                    Method::OrderAsc,
+                    Method::OrderDesc,
+                    Method::OrderRandom => Base::METHOD_TYPE_ORDER,
+                    Method::Equal,
+                    Method::NotEqual,
+                    Method::LessThan,
+                    Method::LessThanEqual,
+                    Method::GreaterThan,
+                    Method::GreaterThanEqual,
+                    Method::Search,
+                    Method::NotSearch,
+                    Method::IsNull,
+                    Method::IsNotNull,
+                    Method::Between,
+                    Method::NotBetween,
+                    Method::StartsWith,
+                    Method::NotStartsWith,
+                    Method::EndsWith,
+                    Method::NotEndsWith,
+                    Method::Contains,
+                    Method::ContainsAny,
+                    Method::NotContains,
+                    Method::And,
+                    Method::Or,
+                    Method::ContainsAll,
+                    Method::ElemMatch,
+                    Method::Crosses,
+                    Method::NotCrosses,
+                    Method::DistanceEqual,
+                    Method::DistanceNotEqual,
+                    Method::DistanceGreaterThan,
+                    Method::DistanceLessThan,
+                    Method::Intersects,
+                    Method::NotIntersects,
+                    Method::Overlaps,
+                    Method::NotOverlaps,
+                    Method::Touches,
+                    Method::NotTouches,
+                    Method::Covers,
+                    Method::NotCovers,
+                    Method::SpatialEquals,
+                    Method::NotSpatialEquals,
+                    Method::VectorDot,
+                    Method::VectorCosine,
+                    Method::VectorEuclidean,
+                    Method::Regex,
+                    Method::Exists,
+                    Method::NotExists => Base::METHOD_TYPE_FILTER,
+                    Method::Distinct => Base::METHOD_TYPE_DISTINCT,
+                    Method::GroupBy => Base::METHOD_TYPE_GROUP_BY,
+                    Method::Having => Base::METHOD_TYPE_HAVING,
+                    Method::Join,
+                    Method::LeftJoin,
+                    Method::RightJoin,
+                    Method::CrossJoin,
+                    Method::FullOuterJoin,
+                    Method::NaturalJoin => Base::METHOD_TYPE_JOIN,
+                    default => '',
+                };
+            }
 
             $methodIsValid = false;
             foreach ($this->validators as $validator) {
                 if ($validator->getMethodType() !== $methodType) {
                     continue;
                 }
-                if (!$validator->isValid($query)) {
-                    $this->message = 'Invalid query: ' . $validator->getDescription();
+                if (! $validator->isValid($query)) {
+                    $this->message = 'Invalid query: '.$validator->getDescription();
+
                     return false;
                 }
 
                 $methodIsValid = true;
             }
 
-            if (!$methodIsValid) {
-                $this->message = 'Invalid query method: ' . $method;
+            if (! $methodIsValid) {
+                $this->message = 'Invalid query method: '.$method->value;
+
                 return false;
             }
         }
@@ -157,8 +280,6 @@ public function isValid($value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -169,8 +290,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Queries/Document.php b/src/Database/Validator/Queries/Document.php
index 5907c50e79..626eacffb7 100644
--- a/src/Database/Validator/Queries/Document.php
+++ b/src/Database/Validator/Queries/Document.php
@@ -3,40 +3,46 @@
 namespace Utopia\Database\Validator\Queries;
 
 use Exception;
-use Utopia\Database\Database;
+use Utopia\Database\Document as BaseDocument;
 use Utopia\Database\Validator\Queries;
+use Utopia\Database\Validator\Query\Join;
 use Utopia\Database\Validator\Query\Select;
+use Utopia\Query\Schema\ColumnType;
 
+/**
+ * Validates queries for single document retrieval, supporting select operations on document attributes.
+ */
 class Document extends Queries
 {
     /**
-     * @param array<mixed> $attributes
-     * @param bool $supportForAttributes
+     * @param  array<BaseDocument>  $attributes
+     *
      * @throws Exception
      */
     public function __construct(array $attributes, bool $supportForAttributes = true)
     {
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$id',
-            'key' => '$id',
-            'type' => Database::VAR_STRING,
+        $attributes[] = new BaseDocument([
+            BaseDocument::ID => BaseDocument::ID,
+            'key' => BaseDocument::ID,
+            'type' => ColumnType::String->value,
             'array' => false,
         ]);
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$createdAt',
-            'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+        $attributes[] = new BaseDocument([
+            BaseDocument::ID => BaseDocument::CREATED_AT,
+            'key' => BaseDocument::CREATED_AT,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$updatedAt',
-            'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+        $attributes[] = new BaseDocument([
+            BaseDocument::ID => BaseDocument::UPDATED_AT,
+            'key' => BaseDocument::UPDATED_AT,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
 
         $validators = [
             new Select($attributes, $supportForAttributes),
+            new Join(),
         ];
 
         parent::__construct($validators);
diff --git a/src/Database/Validator/Queries/Documents.php b/src/Database/Validator/Queries/Documents.php
index 4959a062cf..945a669a16 100644
--- a/src/Database/Validator/Queries/Documents.php
+++ b/src/Database/Validator/Queries/Documents.php
@@ -2,26 +2,31 @@
 
 namespace Utopia\Database\Validator\Queries;
 
-use Utopia\Database\Database;
+use DateTime;
 use Utopia\Database\Document;
 use Utopia\Database\Validator\IndexedQueries;
+use Utopia\Database\Validator\Query\Aggregate;
 use Utopia\Database\Validator\Query\Cursor;
+use Utopia\Database\Validator\Query\Distinct;
 use Utopia\Database\Validator\Query\Filter;
+use Utopia\Database\Validator\Query\GroupBy;
+use Utopia\Database\Validator\Query\Having;
+use Utopia\Database\Validator\Query\Join;
 use Utopia\Database\Validator\Query\Limit;
 use Utopia\Database\Validator\Query\Offset;
 use Utopia\Database\Validator\Query\Order;
 use Utopia\Database\Validator\Query\Select;
+use Utopia\Query\Schema\ColumnType;
 
+/**
+ * Validates queries for document listing, supporting filters, ordering, pagination, aggregation, and joins.
+ */
 class Documents extends IndexedQueries
 {
     /**
-     * @param array<mixed> $attributes
-     * @param array<mixed> $indexes
-     * @param string $idAttributeType
-     * @param int $maxValuesCount
-     * @param \DateTime $minAllowedDate
-     * @param \DateTime $maxAllowedDate
-     * @param bool $supportForAttributes
+     * @param  array<Document>  $attributes
+     * @param  array<Document>  $indexes
+     *
      * @throws \Utopia\Database\Exception
      */
     public function __construct(
@@ -30,33 +35,33 @@ public function __construct(
         string $idAttributeType,
         int $maxValuesCount = 5000,
         int $maxUIDLength = 36,
-        \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
-        \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
+        DateTime $minAllowedDate = new DateTime('0000-01-01'),
+        DateTime $maxAllowedDate = new DateTime('9999-12-31'),
         bool $supportForAttributes = true,
-        bool $supportUnsignedBigInt = true
+        bool $supportUnsignedBigInt = false
     ) {
         $attributes[] = new Document([
-            '$id' => '$id',
-            'key' => '$id',
-            'type' => Database::VAR_STRING,
+            Document::ID => Document::ID,
+            'key' => Document::ID,
+            'type' => ColumnType::String->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
-            '$id' => '$sequence',
-            'key' => '$sequence',
-            'type' => Database::VAR_ID,
+            Document::ID => Document::SEQUENCE,
+            'key' => Document::SEQUENCE,
+            'type' => ColumnType::Id->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
-            '$id' => '$createdAt',
-            'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::CREATED_AT,
+            'key' => Document::CREATED_AT,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
-            '$id' => '$updatedAt',
-            'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::UPDATED_AT,
+            'key' => Document::UPDATED_AT,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
 
@@ -75,6 +80,11 @@ public function __construct(
             ),
             new Order($attributes, $supportForAttributes),
             new Select($attributes, $supportForAttributes),
+            new Join(),
+            new Aggregate(),
+            new GroupBy(),
+            new Having(),
+            new Distinct(),
         ];
 
         parent::__construct($attributes, $indexes, $validators);
diff --git a/src/Database/Validator/Query/Aggregate.php b/src/Database/Validator/Query/Aggregate.php
new file mode 100644
index 0000000000..4b74a46039
--- /dev/null
+++ b/src/Database/Validator/Query/Aggregate.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+/**
+ * Validates aggregate query methods such as count, sum, avg, min, max, stddev, and variance.
+ */
+class Aggregate extends Base
+{
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
+    public function getMethodType(): string
+    {
+        return self::METHOD_TYPE_AGGREGATE;
+    }
+}
diff --git a/src/Database/Validator/Query/Base.php b/src/Database/Validator/Query/Base.php
index a37fdd65a9..9a6526debf 100644
--- a/src/Database/Validator/Query/Base.php
+++ b/src/Database/Validator/Query/Base.php
@@ -2,25 +2,42 @@
 
 namespace Utopia\Database\Validator\Query;
 
+use Utopia\Database\Query;
 use Utopia\Validator;
 
+/**
+ * Abstract base class for query method validators, providing shared constants and common methods.
+ */
 abstract class Base extends Validator
 {
     public const METHOD_TYPE_LIMIT = 'limit';
+
     public const METHOD_TYPE_OFFSET = 'offset';
+
     public const METHOD_TYPE_CURSOR = 'cursor';
+
     public const METHOD_TYPE_ORDER = 'order';
+
     public const METHOD_TYPE_FILTER = 'filter';
+
     public const METHOD_TYPE_SELECT = 'select';
 
+    public const METHOD_TYPE_JOIN = 'join';
+
+    public const METHOD_TYPE_AGGREGATE = 'aggregate';
+
+    public const METHOD_TYPE_GROUP_BY = 'groupBy';
+
+    public const METHOD_TYPE_HAVING = 'having';
+
+    public const METHOD_TYPE_DISTINCT = 'distinct';
+
     protected string $message = 'Invalid query';
 
     /**
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -31,8 +48,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -43,14 +58,40 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
         return self::TYPE_OBJECT;
     }
 
+    /**
+     * Rejects anything that is not a Query, then defers to the subclass rule.
+     *
+     * Subclasses that validate a Query further override isValidQuery(), not
+     * this, so the not-a-Query message stays the same for every method that
+     * uses it.
+     *
+     * @param  mixed  $value
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        return $this->isValidQuery($value);
+    }
+
+    /**
+     * Validate a Query beyond its type. A method with no further rule inherits this.
+     */
+    protected function isValidQuery(Query $query): bool
+    {
+        return true;
+    }
+
     /**
      * Returns what type of query this Validator is for
      */
diff --git a/src/Database/Validator/Query/Cursor.php b/src/Database/Validator/Query/Cursor.php
index 58053fe606..615a371362 100644
--- a/src/Database/Validator/Query/Cursor.php
+++ b/src/Database/Validator/Query/Cursor.php
@@ -6,9 +6,18 @@
 use Utopia\Database\Document;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\UID;
+use Utopia\Query\Method;
 
+/**
+ * Validates cursor-based pagination queries (cursorAfter and cursorBefore).
+ */
 class Cursor extends Base
 {
+    /**
+     * Create a new cursor query validator.
+     *
+     * @param int $maxLength Maximum allowed UID length for cursor values
+     */
     public function __construct(private readonly int $maxLength = Database::MAX_UID_DEFAULT_LENGTH)
     {
     }
@@ -20,18 +29,17 @@ public function __construct(private readonly int $maxLength = Database::MAX_UID_
      *
      * Otherwise, returns false
      *
-     * @param Query $value
-     * @return bool
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof Query) {
+        if (! $value instanceof Query) {
             return false;
         }
 
         $method = $value->getMethod();
 
-        if ($method === Query::TYPE_CURSOR_AFTER || $method === Query::TYPE_CURSOR_BEFORE) {
+        if ($method === Method::CursorAfter || $method === Method::CursorBefore) {
             $cursor = $value->getValue();
 
             if ($cursor instanceof Document) {
@@ -42,13 +50,19 @@ public function isValid($value): bool
             if ($validator->isValid($cursor)) {
                 return true;
             }
-            $this->message = 'Invalid cursor: ' . $validator->getDescription();
+            $this->message = 'Invalid cursor: '.$validator->getDescription();
+
             return false;
         }
 
         return false;
     }
 
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_CURSOR;
diff --git a/src/Database/Validator/Query/Distinct.php b/src/Database/Validator/Query/Distinct.php
new file mode 100644
index 0000000000..3f84ecc297
--- /dev/null
+++ b/src/Database/Validator/Query/Distinct.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+/**
+ * Validates distinct query methods for deduplicating result sets.
+ */
+class Distinct extends Base
+{
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
+    public function getMethodType(): string
+    {
+        return self::METHOD_TYPE_DISTINCT;
+    }
+}
diff --git a/src/Database/Validator/Query/Filter.php b/src/Database/Validator/Query/Filter.php
index ca124ec280..2d19176550 100644
--- a/src/Database/Validator/Query/Filter.php
+++ b/src/Database/Validator/Query/Filter.php
@@ -2,17 +2,25 @@
 
 namespace Utopia\Database\Validator\Query;
 
-use Utopia\Database\Database;
+use DateTime;
+use Utopia\Database\Attribute;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
 use Utopia\Database\Validator\BigInt;
 use Utopia\Database\Validator\Datetime as DatetimeValidator;
 use Utopia\Database\Validator\Sequence;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\FloatValidator;
 use Utopia\Validator\Integer;
 use Utopia\Validator\Text;
 
+/**
+ * Validates filter query methods by checking attribute existence, type compatibility, and value constraints.
+ */
 class Filter extends Base
 {
     /**
@@ -21,52 +29,73 @@ class Filter extends Base
     protected array $schema = [];
 
     /**
-     * @param array<Document> $attributes
-     * @param int $maxValuesCount
-     * @param \DateTime $minAllowedDate
-     * @param \DateTime $maxAllowedDate
+     * @var array<string, true>
+     */
+    protected array $joinAliases = [];
+
+    /**
+     * @param  array<Document>  $attributes
      */
     public function __construct(
         array $attributes,
         private readonly string $idAttributeType,
         private readonly int $maxValuesCount = 5000,
-        private readonly \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
-        private readonly \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
-        private readonly bool $supportForAttributes = true,
-        private readonly bool $supportUnsignedBigInt = true
+        private readonly DateTime $minAllowedDate = new DateTime('0000-01-01'),
+        private readonly DateTime $maxAllowedDate = new DateTime('9999-12-31'),
+        private bool $supportForAttributes = true,
+        private readonly bool $supportUnsignedBigInt = false
     ) {
         foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getId())] = $attribute->getArrayCopy();
+            /** @var string $attrKey */
+            $attrKey = $attribute->getAttribute('key', $attribute->getId());
+            $copy = $attribute->getArrayCopy();
+            // Convert known type strings to ColumnType enum for typed comparisons.
+            // Unknown strings are preserved as-is so the downstream switch can
+            // emit a recoverable "Unknown Data type" error instead of throwing.
+            if (isset($copy['type']) && \is_string($copy['type'])) {
+                $copy['type'] = Attribute::tryNormalizeType($copy['type']) ?? $copy['type'];
+            }
+            $this->schema[$attrKey] = $copy;
         }
     }
 
-    /**
-     * @param string $attribute
-     * @return bool
-     */
     protected function isValidAttribute(string $attribute): bool
     {
+        /** @var array<string, mixed> $attributeSchema */
+        $attributeSchema = $this->schema[$attribute] ?? [];
+        /** @var array<string> $filters */
+        $filters = $attributeSchema['filters'] ?? [];
         if (
-            \in_array('encrypt', $this->schema[$attribute]['filters'] ?? [])
+            \in_array('encrypt', $filters)
         ) {
-            $this->message = 'Cannot query encrypted attribute: ' . $attribute;
+            $this->message = 'Cannot query encrypted attribute: '.$attribute;
+
             return false;
         }
 
-        if (\str_contains($attribute, '.')) {
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false) {
             // Check for special symbol `.`
             if (isset($this->schema[$attribute])) {
                 return true;
             }
 
+            $alias = \substr($attribute, 0, $dot);
+            $column = \substr($attribute, $dot + 1);
+
+            if (isset($this->joinAliases[$alias]) && $this->isAllowedJoinColumn($column)) {
+                return true;
+            }
+
             // For relationships, just validate the top level.
             // will validate each nested level during the recursive calls.
-            $attribute = \explode('.', $attribute)[0];
+            $attribute = $alias;
         }
 
         // Search for attribute in schema
-        if ($this->supportForAttributes && !isset($this->schema[$attribute])) {
-            $this->message = 'Attribute not found in schema: ' . $attribute;
+        if ($this->supportForAttributes && ! isset($this->schema[$attribute])) {
+            $this->message = 'Attribute not found in schema: '.$attribute;
+
             return false;
         }
 
@@ -74,231 +103,317 @@ protected function isValidAttribute(string $attribute): bool
     }
 
     /**
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param string $method
-     * @return bool
+     * @param  array<mixed>  $values
      */
-    protected function isValidAttributeAndValues(string $attribute, array $values, string $method): bool
+    protected function isValidAttributeAndValues(string $attribute, array $values, Method $method): bool
     {
-        if (!$this->isValidAttribute($attribute)) {
+        if (! $this->isValidAttribute($attribute)) {
             return false;
         }
 
         $originalAttribute = $attribute;
         // isset check if for special symbols "." in the attribute name
         // same for nested path on object
-        if (\str_contains($attribute, '.') && !isset($this->schema[$attribute])) {
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false && ! isset($this->schema[$attribute])) {
+            $alias = \substr($attribute, 0, $dot);
+            $column = \substr($attribute, $dot + 1);
+
+            // Joined columns are not in this collection's schema; skip local type checks.
+            if (isset($this->joinAliases[$alias]) && $this->isAllowedJoinColumn($column)) {
+                if (count($values) > $this->maxValuesCount) {
+                    $this->message = 'Query on attribute has greater than '.$this->maxValuesCount.' values: '.$attribute;
+
+                    return false;
+                }
+
+                return true;
+            }
+
             // For relationships, just validate the top level.
             // Utopia will validate each nested level during the recursive calls.
-            $attribute = \explode('.', $attribute)[0];
+            $attribute = $alias;
         }
 
         // exists and notExists queries don't require values, just attribute validation
-        if (in_array($method, [Query::TYPE_EXISTS, Query::TYPE_NOT_EXISTS])) {
+        if (in_array($method, [Method::Exists, Method::NotExists])) {
             // Validate attribute (handles encrypted attributes, schemaless mode, etc.)
             return $this->isValidAttribute($attribute);
         }
 
-        if (!$this->supportForAttributes && !isset($this->schema[$attribute])) {
+        if (! $this->supportForAttributes && ! isset($this->schema[$attribute])) {
             // First check maxValuesCount guard for any IN-style value arrays
             if (count($values) > $this->maxValuesCount) {
-                $this->message = 'Query on attribute has greater than ' . $this->maxValuesCount . ' values: ' . $attribute;
+                $this->message = 'Query on attribute has greater than '.$this->maxValuesCount.' values: '.$attribute;
+
                 return false;
             }
 
             return true;
         }
+        /** @var array<string, mixed> $attributeSchema */
         $attributeSchema = $this->schema[$attribute];
 
         // Skip value validation for nested relationship queries (e.g., author.age)
         // The values will be validated when querying the related collection
-        if ($attributeSchema['type'] === Database::VAR_RELATIONSHIP && $originalAttribute !== $attribute) {
+        /** @var ColumnType|null $schemaType */
+        $schemaType = $attributeSchema['type'] ?? null;
+        if ($schemaType === ColumnType::Relationship && $originalAttribute !== $attribute) {
             return true;
         }
 
         if (count($values) > $this->maxValuesCount) {
-            $this->message = 'Query on attribute has greater than ' . $this->maxValuesCount . ' values: ' . $attribute;
-            return false;
-        }
+            $this->message = 'Query on attribute has greater than '.$this->maxValuesCount.' values: '.$attribute;
 
-        if (!$this->supportForAttributes && !isset($this->schema[$attribute])) {
-            return true;
+            return false;
         }
-        $attributeSchema = $this->schema[$attribute];
 
-        $attributeType = $attributeSchema['type'];
+        /** @var ColumnType|null $attributeType */
+        $attributeType = $attributeSchema['type'] ?? null;
 
-        $isDottedOnObject = \str_contains($originalAttribute, '.') && $attributeType === Database::VAR_OBJECT;
+        $isDottedOnObject = \str_contains($originalAttribute, '.') && $attributeType === ColumnType::Object;
 
         // If the query method is spatial-only, the attribute must be a spatial type
         $query = new Query($method);
-        if ($query->isSpatialQuery() && !in_array($attributeType, Database::SPATIAL_TYPES, true)) {
-            $this->message = 'Spatial query "' . $method . '" cannot be applied on non-spatial attribute: ' . $attribute;
+        if ($query->isSpatialQuery() && ! in_array($attributeType, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+            $this->message = 'Spatial query "'.$method->value.'" cannot be applied on non-spatial attribute: '.$attribute;
+
             return false;
         }
 
-        foreach ($values as $value) {
-            $validator = null;
-
+        // The validator depends only on the column's declared type, which does
+        // not change between values, so build it once instead of once per
+        // value. Object containment, spatial and vector checks read the value
+        // itself and stay in the loop below.
+        //
+        // Guarded on a non-empty value list because the unknown-type refusal
+        // used to sit inside the loop, so a query with no values never reached
+        // it. Hoisting it unguarded would start rejecting those.
+        $validator = null;
+
+        if ($values !== []) {
             switch ($attributeType) {
-                case Database::VAR_ID:
-                    $validator = new Sequence($this->idAttributeType, $attribute === '$sequence');
+                case ColumnType::Id:
+                    $validator = new Sequence($this->idAttributeType, $attribute === Document::SEQUENCE);
                     break;
 
-                case Database::VAR_STRING:
-                case Database::VAR_VARCHAR:
-                case Database::VAR_TEXT:
-                case Database::VAR_MEDIUMTEXT:
-                case Database::VAR_LONGTEXT:
+                case ColumnType::String:
+                case ColumnType::Varchar:
+                case ColumnType::Text:
+                case ColumnType::MediumText:
+                case ColumnType::LongText:
+                case ColumnType::Uuid7:
+                case ColumnType::Enum:
+                case ColumnType::Json:
+                case ColumnType::Binary:
                     $validator = new Text(0, 0);
                     break;
 
-                case Database::VAR_INTEGER:
+                case ColumnType::Integer:
+                case ColumnType::Serial:
+                case ColumnType::SmallSerial:
+                    /** @var int $size */
                     $size = $attributeSchema['size'] ?? 4;
+                    /** @var bool $signed */
                     $signed = $attributeSchema['signed'] ?? true;
                     $bits = $size >= 8 ? 64 : 32;
                     // For 64-bit unsigned, use signed since PHP doesn't support true 64-bit unsigned
-                    $unsigned = !$signed && $bits < 64;
+                    $unsigned = ! $signed && $bits < 64;
                     $validator = new Integer(false, $bits, $unsigned);
                     break;
 
-                case Database::VAR_BIGINT:
+                case ColumnType::BigInteger:
+                case ColumnType::BigSerial:
+                    /** @var bool $signed */
                     $signed = $attributeSchema['signed'] ?? true;
                     $validator = new BigInt($signed, $this->supportUnsignedBigInt);
                     break;
 
-                case Database::VAR_FLOAT:
+                case ColumnType::Float:
+                case ColumnType::Double:
                     $validator = new FloatValidator();
                     break;
 
-                case Database::VAR_BOOLEAN:
+                case ColumnType::Boolean:
                     $validator = new Boolean();
                     break;
 
-                case Database::VAR_DATETIME:
+                case ColumnType::Datetime:
+                case ColumnType::Timestamp:
                     $validator = new DatetimeValidator(
                         min: $this->minAllowedDate,
                         max: $this->maxAllowedDate
                     );
                     break;
 
-                case Database::VAR_RELATIONSHIP:
+                case ColumnType::Relationship:
                     $validator = new Text(255, 0); // The query is always on uid
                     break;
 
-                case Database::VAR_OBJECT:
+                case ColumnType::Object:
                     // For dotted attributes on objects, validate as string (path queries)
                     if ($isDottedOnObject) {
                         $validator = new Text(0, 0);
+                    }
+                    break;
+
+                case ColumnType::Point:
+                case ColumnType::Linestring:
+                case ColumnType::Polygon:
+                case ColumnType::Vector:
+                    break;
+
+                default:
+                    $this->message = 'Unknown Data type';
+
+                    return false;
+            }
+        }
+
+        foreach ($values as $value) {
+            switch ($attributeType) {
+                case ColumnType::Object:
+                    if ($isDottedOnObject) {
                         break;
                     }
 
                     // object containment queries on the base object attribute
-                    elseif (\in_array($method, [Query::TYPE_EQUAL, Query::TYPE_NOT_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_CONTAINS_ALL, Query::TYPE_NOT_CONTAINS], true)
-                        && !$this->isValidObjectQueryValues($value)) {
-                        $this->message = 'Invalid object query structure for attribute "' . $attribute . '"';
+                    if (\in_array($method, [Method::Equal, Method::NotEqual, Method::Contains, Method::ContainsAny, Method::ContainsAll, Method::NotContains], true)
+                        && ! $this->isValidObjectQueryValues($value)) {
+                        $this->message = 'Invalid object query structure for attribute "'.$attribute.'"';
+
                         return false;
                     }
 
                     continue 2;
-                case Database::VAR_POINT:
-                case Database::VAR_LINESTRING:
-                case Database::VAR_POLYGON:
-                    if (!is_array($value)) {
+
+                case ColumnType::Point:
+                case ColumnType::Linestring:
+                case ColumnType::Polygon:
+                    if (! is_array($value)) {
                         $this->message = 'Spatial data must be an array';
+
                         return false;
                     }
+
                     continue 2;
 
-                case Database::VAR_VECTOR:
+                case ColumnType::Vector:
                     // For vector queries, validate that the value is an array of floats
-                    if (!is_array($value)) {
+                    if (! is_array($value)) {
                         $this->message = 'Vector query value must be an array';
+
                         return false;
                     }
                     foreach ($value as $component) {
-                        if (!is_numeric($component)) {
+                        if (! is_numeric($component)) {
                             $this->message = 'Vector query value must contain only numeric values';
+
                             return false;
                         }
                     }
                     // Check size match
+                    /** @var int $expectedSize */
                     $expectedSize = $attributeSchema['size'] ?? 0;
                     if (count($value) !== $expectedSize) {
                         $this->message = "Vector query value must have {$expectedSize} elements";
+
                         return false;
                     }
+
                     continue 2;
-                default:
-                    $this->message = 'Unknown Data type';
-                    return false;
             }
 
-            if (!$validator->isValid($value)) {
-                $this->message = 'Query value is invalid for attribute "' . $attribute . '"';
+            if ($validator !== null && ! $validator->isValid($value)) {
+                $this->message = 'Query value is invalid for attribute "'.$attribute.'"';
+
                 return false;
             }
         }
 
-        if ($attributeSchema['type'] === 'relationship') {
+        if ($attributeType === ColumnType::Relationship) {
             /**
              * We can not disable relationship query since we have logic that use it,
              * so instead we validate against the relation type
              */
-            $options = $attributeSchema['options'];
+            $options = $attributeSchema['options'] ?? [];
 
-            if ($options['relationType'] === Database::RELATION_ONE_TO_ONE && $options['twoWay'] === false && $options['side'] === Database::RELATION_SIDE_CHILD) {
+            if ($options instanceof Document) {
+                $options = $options->getArrayCopy();
+            }
+
+            /** @var array<string, mixed> $options */
+
+            /** @var string $relationTypeStr */
+            $relationTypeStr = $options['relationType'] ?? '';
+            /** @var bool $twoWay */
+            $twoWay = $options['twoWay'] ?? false;
+            /** @var string $sideStr */
+            $sideStr = $options['side'] ?? '';
+
+            $relationType = $relationTypeStr !== '' ? RelationType::from($relationTypeStr) : null;
+            $side = $sideStr !== '' ? RelationSide::from($sideStr) : null;
+
+            if ($relationType === RelationType::OneToOne && $twoWay === false && $side === RelationSide::Child) {
                 $this->message = 'Cannot query on virtual relationship attribute';
+
                 return false;
             }
 
-            if ($options['relationType'] === Database::RELATION_ONE_TO_MANY && $options['side'] === Database::RELATION_SIDE_PARENT) {
+            if ($relationType === RelationType::OneToMany && $side === RelationSide::Parent) {
                 $this->message = 'Cannot query on virtual relationship attribute';
+
                 return false;
             }
 
-            if ($options['relationType'] === Database::RELATION_MANY_TO_ONE && $options['side'] === Database::RELATION_SIDE_CHILD) {
+            if ($relationType === RelationType::ManyToOne && $side === RelationSide::Child) {
                 $this->message = 'Cannot query on virtual relationship attribute';
+
                 return false;
             }
 
-            if ($options['relationType'] === Database::RELATION_MANY_TO_MANY) {
+            if ($relationType === RelationType::ManyToMany) {
                 $this->message = 'Cannot query on virtual relationship attribute';
+
                 return false;
             }
         }
 
+        /** @var bool $array */
         $array = $attributeSchema['array'] ?? false;
 
         if (
-            !$array &&
-            in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_CONTAINS_ALL, Query::TYPE_NOT_CONTAINS]) &&
-            !in_array($attributeSchema['type'], Database::STRING_TYPES) &&
-            $attributeSchema['type'] !== Database::VAR_OBJECT &&
-            !in_array($attributeSchema['type'], Database::SPATIAL_TYPES)
+            ! $array &&
+            in_array($method, [Method::Contains, Method::ContainsAny, Method::ContainsAll, Method::NotContains]) &&
+            ! in_array($attributeType, [ColumnType::String, ColumnType::Varchar, ColumnType::Text, ColumnType::MediumText, ColumnType::LongText]) &&
+            $attributeType !== ColumnType::Object &&
+            ! in_array($attributeType, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon])
         ) {
-            $queryType = $method === Query::TYPE_NOT_CONTAINS ? 'notContains' : 'contains';
-            $this->message = 'Cannot query ' . $queryType . ' on attribute "' . $attribute . '" because it is not an array, string, or object.';
+            $queryType = $method === Method::NotContains ? 'notContains' : 'contains';
+            $this->message = 'Cannot query '.$queryType.' on attribute "'.$attribute.'" because it is not an array, string, or object.';
+
             return false;
         }
 
         if (
             $array &&
-            !in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_CONTAINS_ANY, Query::TYPE_CONTAINS_ALL, Query::TYPE_NOT_CONTAINS, Query::TYPE_IS_NULL, Query::TYPE_IS_NOT_NULL, Query::TYPE_EXISTS, Query::TYPE_NOT_EXISTS])
+            ! in_array($method, [Method::Contains, Method::ContainsAny, Method::ContainsAll, Method::NotContains, Method::IsNull, Method::IsNotNull, Method::Exists, Method::NotExists])
         ) {
-            $this->message = 'Cannot query '. $method .' on attribute "' . $attribute . '" because it is an array.';
+            $this->message = 'Cannot query '.$method->value.' on attribute "'.$attribute.'" because it is an array.';
+
             return false;
         }
 
         // Vector queries can only be used on vector attributes (not arrays)
-        if (\in_array($method, Query::VECTOR_TYPES)) {
-            if ($attributeSchema['type'] !== Database::VAR_VECTOR) {
+        if (\in_array($method, [Method::VectorDot, Method::VectorCosine, Method::VectorEuclidean])) {
+            if ($attributeType !== ColumnType::Vector) {
                 $this->message = 'Vector queries can only be used on vector attributes';
+
                 return false;
             }
             if ($array) {
                 $this->message = 'Vector queries cannot be used on array attributes';
+
                 return false;
             }
         }
@@ -307,8 +422,7 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
     }
 
     /**
-     * @param array<mixed> $values
-     * @return bool
+     * @param  array<mixed>  $values
      */
     protected function isEmpty(array $values): bool
     {
@@ -333,13 +447,10 @@ protected function isEmpty(array $values): bool
      *   ['a' => [1, 2], 'b' => [212]]        // multiple top-level paths
      *   ['projects' => [[...]]]              // list of objects
      *   ['role' => ['name' => [...], 'ex' => [...]]]  // multiple nested paths
-     *
-     * @param mixed $values
-     * @return bool
      */
     private function isValidObjectQueryValues(mixed $values): bool
     {
-        if (!is_array($values)) {
+        if (! is_array($values)) {
             return true;
         }
 
@@ -359,7 +470,7 @@ private function isValidObjectQueryValues(mixed $values): bool
         }
 
         foreach ($values as $value) {
-            if (!$this->isValidObjectQueryValues($value)) {
+            if (! $this->isValidObjectQueryValues($value)) {
                 return false;
             }
         }
@@ -374,145 +485,212 @@ private function isValidObjectQueryValues(mixed $values): bool
      *
      * Otherwise, returns false
      *
-     * @param Query $value
-     * @return bool
+     * @param  Query  $value
      */
     public function isValid($value): bool
     {
         $method = $value->getMethod();
         $attribute = $value->getAttribute();
         switch ($method) {
-            case Query::TYPE_EQUAL:
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_CONTAINS_ANY:
-            case Query::TYPE_NOT_CONTAINS:
-            case Query::TYPE_CONTAINS_ALL:
-            case Query::TYPE_EXISTS:
-            case Query::TYPE_NOT_EXISTS:
+            case Method::Equal:
+            case Method::Contains:
+            case Method::ContainsAny:
+            case Method::NotContains:
+            case Method::ContainsAll:
+            case Method::Exists:
+            case Method::NotExists:
                 if ($this->isEmpty($value->getValues())) {
-                    $this->message = \ucfirst($method) . ' queries require at least one value.';
+                    $this->message = \ucfirst($method->value).' queries require at least one value.';
+
                     return false;
                 }
 
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
-            case Query::TYPE_DISTANCE_EQUAL:
-            case Query::TYPE_DISTANCE_NOT_EQUAL:
-            case Query::TYPE_DISTANCE_GREATER_THAN:
-            case Query::TYPE_DISTANCE_LESS_THAN:
-                if (count($value->getValues()) !== 1 || !is_array($value->getValues()[0]) || count($value->getValues()[0]) !== 3) {
+            case Method::DistanceEqual:
+            case Method::DistanceNotEqual:
+            case Method::DistanceGreaterThan:
+            case Method::DistanceLessThan:
+                if (count($value->getValues()) !== 1 || ! is_array($value->getValues()[0]) || count($value->getValues()[0]) !== 3) {
                     $this->message = 'Distance query requires [[geometry, distance]] parameters';
+
                     return false;
                 }
+
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
-            case Query::TYPE_NOT_EQUAL:
-            case Query::TYPE_LESSER:
-            case Query::TYPE_LESSER_EQUAL:
-            case Query::TYPE_GREATER:
-            case Query::TYPE_GREATER_EQUAL:
-            case Query::TYPE_SEARCH:
-            case Query::TYPE_NOT_SEARCH:
-            case Query::TYPE_STARTS_WITH:
-            case Query::TYPE_NOT_STARTS_WITH:
-            case Query::TYPE_ENDS_WITH:
-            case Query::TYPE_NOT_ENDS_WITH:
-            case Query::TYPE_REGEX:
+            case Method::NotEqual:
+            case Method::LessThan:
+            case Method::LessThanEqual:
+            case Method::GreaterThan:
+            case Method::GreaterThanEqual:
+            case Method::Search:
+            case Method::NotSearch:
+            case Method::StartsWith:
+            case Method::NotStartsWith:
+            case Method::EndsWith:
+            case Method::NotEndsWith:
+            case Method::Regex:
                 if (count($value->getValues()) != 1) {
-                    $this->message = \ucfirst($method) . ' queries require exactly one value.';
+                    $this->message = \ucfirst($method->value).' queries require exactly one value.';
+
                     return false;
                 }
 
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
-            case Query::TYPE_BETWEEN:
-            case Query::TYPE_NOT_BETWEEN:
+            case Method::Between:
+            case Method::NotBetween:
                 if (count($value->getValues()) != 2) {
-                    $this->message = \ucfirst($method) . ' queries require exactly two values.';
+                    $this->message = \ucfirst($method->value).' queries require exactly two values.';
+
                     return false;
                 }
 
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
+            case Method::IsNull:
+            case Method::IsNotNull:
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
 
-            case Query::TYPE_VECTOR_DOT:
-            case Query::TYPE_VECTOR_COSINE:
-            case Query::TYPE_VECTOR_EUCLIDEAN:
+            case Method::VectorDot:
+            case Method::VectorCosine:
+            case Method::VectorEuclidean:
                 // Validate that the attribute is a vector type
-                if (!$this->isValidAttribute($attribute)) {
+                if (! $this->isValidAttribute($attribute)) {
                     return false;
                 }
 
                 // Handle dotted attributes (relationships)
                 $attributeKey = $attribute;
-                if (\str_contains($attributeKey, '.') && !isset($this->schema[$attributeKey])) {
-                    $attributeKey = \explode('.', $attributeKey)[0];
+                $dot = \strpos($attributeKey, '.');
+                if ($dot !== false && ! isset($this->schema[$attributeKey])) {
+                    $alias = \substr($attributeKey, 0, $dot);
+                    $column = \substr($attributeKey, $dot + 1);
+
+                    if (isset($this->joinAliases[$alias]) && $this->isAllowedJoinColumn($column)) {
+                        if (count($value->getValues()) != 1) {
+                            $this->message = \ucfirst($method->value).' queries require exactly one vector value.';
+
+                            return false;
+                        }
+
+                        return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
+                    }
+
+                    $attributeKey = $alias;
                 }
 
+                /** @var array<string, mixed> $attributeSchema */
                 $attributeSchema = $this->schema[$attributeKey];
-                if ($attributeSchema['type'] !== Database::VAR_VECTOR) {
+                /** @var ColumnType|null $vectorAttrType */
+                $vectorAttrType = $attributeSchema['type'] ?? null;
+                if ($vectorAttrType !== ColumnType::Vector) {
                     $this->message = 'Vector queries can only be used on vector attributes';
+
                     return false;
                 }
 
                 if (count($value->getValues()) != 1) {
-                    $this->message = \ucfirst($method) . ' queries require exactly one vector value.';
+                    $this->message = \ucfirst($method->value).' queries require exactly one vector value.';
+
                     return false;
                 }
 
                 return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
-            case Query::TYPE_OR:
-            case Query::TYPE_AND:
-                $filters = Query::groupByType($value->getValues())['filters'];
+            case Method::Or:
+            case Method::And:
+                /** @var list<Query|string> $andOrValues */
+                $andOrValues = $value->getValues();
+                $nestedQueries = [];
+                foreach ($andOrValues as $nested) {
+                    if (! $nested instanceof Query) {
+                        $this->message = \ucfirst($method->value).' queries can only contain filter queries';
+
+                        return false;
+                    }
+                    $nestedQueries[] = $nested;
+                }
+
+                $filters = Query::groupForDatabase($nestedQueries)['filters'];
+
+                if (count($nestedQueries) !== count($filters)) {
+                    $this->message = \ucfirst($method->value).' queries can only contain filter queries';
 
-                if (count($value->getValues()) !== count($filters)) {
-                    $this->message = \ucfirst($method) . ' queries can only contain filter queries';
                     return false;
                 }
 
                 if (count($filters) < 2) {
-                    $this->message = \ucfirst($method) . ' queries require at least two queries';
+                    $this->message = \ucfirst($method->value).' queries require at least two queries';
+
                     return false;
                 }
 
+                foreach ($nestedQueries as $nested) {
+                    if (! $this->isValid($nested)) {
+                        return false;
+                    }
+                }
+
                 return true;
 
-            case Query::TYPE_ELEM_MATCH:
+            case Method::ElemMatch:
                 // elemMatch is not supported when adapter supports attributes (schema mode)
                 if ($this->supportForAttributes) {
                     $this->message = 'elemMatch is not supported by the database';
+
                     return false;
                 }
 
                 // Validate that the attribute (array field) exists
-                if (!$this->isValidAttribute($attribute)) {
+                if (! $this->isValidAttribute($attribute)) {
                     return false;
                 }
 
                 // For schemaless mode, allow elemMatch on any attribute
                 // Validate nested queries are filter queries
-                $filters = Query::groupByType($value->getValues())['filters'];
-                if (count($value->getValues()) !== count($filters)) {
+                /** @var list<Query|string> $elemMatchValues */
+                $elemMatchValues = $value->getValues();
+                $nestedQueries = [];
+                foreach ($elemMatchValues as $nested) {
+                    if (! $nested instanceof Query) {
+                        $this->message = 'elemMatch queries can only contain filter queries';
+
+                        return false;
+                    }
+                    $nestedQueries[] = $nested;
+                }
+
+                $filters = Query::groupForDatabase($nestedQueries)['filters'];
+                if (count($nestedQueries) !== count($filters)) {
                     $this->message = 'elemMatch queries can only contain filter queries';
+
                     return false;
                 }
 
                 if (count($filters) < 1) {
                     $this->message = 'elemMatch queries require at least one query';
+
                     return false;
                 }
+
+                foreach ($nestedQueries as $nested) {
+                    if (! $this->isValid($nested)) {
+                        return false;
+                    }
+                }
+
                 return true;
 
             default:
                 // Handle spatial query types and any other query types
                 if ($value->isSpatialQuery()) {
                     if ($this->isEmpty($value->getValues())) {
-                        $this->message = \ucfirst($method) . ' queries require at least one value.';
+                        $this->message = \ucfirst($method->value).' queries require at least one value.';
+
                         return false;
                     }
+
                     return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
                 }
 
@@ -520,11 +698,39 @@ public function isValid($value): bool
         }
     }
 
+    /**
+     * @param  array<string>  $aliases
+     */
+    public function allowJoinAliases(array $aliases): void
+    {
+        foreach ($aliases as $alias) {
+            if ($alias !== '') {
+                $this->joinAliases[$alias] = true;
+            }
+        }
+    }
+
+    public function resetJoinAliases(): void
+    {
+        $this->joinAliases = [];
+    }
+
+    private function isAllowedJoinColumn(string $column): bool
+    {
+        return $column !== '' && \preg_match('/^[A-Za-z_$][A-Za-z0-9_$]*$/', $column) === 1;
+    }
+
+    /**
+     * Get the maximum number of values allowed in a single filter query.
+     */
     public function getMaxValuesCount(): int
     {
         return $this->maxValuesCount;
     }
 
+    /**
+     * Get the method type this validator handles.
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_FILTER;
diff --git a/src/Database/Validator/Query/GroupBy.php b/src/Database/Validator/Query/GroupBy.php
new file mode 100644
index 0000000000..ee3ec3091c
--- /dev/null
+++ b/src/Database/Validator/Query/GroupBy.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\Query;
+
+/**
+ * Validates groupBy query methods ensuring at least one grouping attribute is specified.
+ */
+class GroupBy extends Base
+{
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
+    public function getMethodType(): string
+    {
+        return self::METHOD_TYPE_GROUP_BY;
+    }
+
+    /**
+     * Validate a groupBy query has at least one non-empty attribute.
+     */
+    protected function isValidQuery(Query $query): bool
+    {
+        $columns = $query->getValues();
+        if (empty($columns)) {
+            $this->message = 'GroupBy requires at least one attribute';
+
+            return false;
+        }
+
+        foreach ($columns as $column) {
+            if (! \is_string($column) || $column === '') {
+                $this->message = 'GroupBy attributes must be non-empty strings';
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Having.php b/src/Database/Validator/Query/Having.php
new file mode 100644
index 0000000000..f6264d9b33
--- /dev/null
+++ b/src/Database/Validator/Query/Having.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\Query;
+
+/**
+ * Validates having query methods ensuring at least one condition is specified.
+ */
+class Having extends Base
+{
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
+    public function getMethodType(): string
+    {
+        return self::METHOD_TYPE_HAVING;
+    }
+
+    /**
+     * Validate a having query has at least one condition, each a Query.
+     */
+    protected function isValidQuery(Query $query): bool
+    {
+        $conditions = $query->getValues();
+        if (empty($conditions)) {
+            $this->message = 'Having requires at least one condition';
+
+            return false;
+        }
+
+        foreach ($conditions as $condition) {
+            if (! $condition instanceof Query) {
+                $this->message = 'Having conditions must be Query instances';
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Join.php b/src/Database/Validator/Query/Join.php
new file mode 100644
index 0000000000..57c7ed4d26
--- /dev/null
+++ b/src/Database/Validator/Query/Join.php
@@ -0,0 +1,76 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\Query;
+use Utopia\Query\Method;
+
+/**
+ * Validates join query methods ensuring a target table name is specified.
+ */
+class Join extends Base
+{
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
+    public function getMethodType(): string
+    {
+        return self::METHOD_TYPE_JOIN;
+    }
+
+    /**
+     * Validate a join query names a table, and that any ON conditions are well formed.
+     */
+    protected function isValidQuery(Query $query): bool
+    {
+        if ($query->getMethod() === Method::NaturalJoin) {
+            $this->message = 'Natural joins are not supported';
+
+            return false;
+        }
+
+        $table = $query->getAttribute();
+        if (empty($table)) {
+            $this->message = 'Join requires a table name';
+
+            return false;
+        }
+
+        if (! $query->isNestedJoin()) {
+            return true;
+        }
+
+        $onQueries = $query->getJoinOnQueries();
+        if ($onQueries === []) {
+            $this->message = 'Join ON requires at least one condition';
+
+            return false;
+        }
+
+        $allowedOperators = ['=', '!=', '<', '>', '<=', '>=', '<>'];
+        foreach ($onQueries as $onQuery) {
+            if ($onQuery->getMethod() !== Method::On) {
+                continue;
+            }
+
+            $values = $onQuery->getValues();
+            $left = $values[0] ?? '';
+            $operator = $values[1] ?? '=';
+            $right = $values[2] ?? '';
+            if (! \is_string($left) || $left === '' || ! \is_string($right) || $right === '') {
+                $this->message = 'Join ON requires left and right columns';
+
+                return false;
+            }
+            if (! \is_string($operator) || ! \in_array($operator, $allowedOperators, true)) {
+                $this->message = 'Invalid join operator: '.(\is_string($operator) ? $operator : \gettype($operator));
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Limit.php b/src/Database/Validator/Query/Limit.php
index facc266d75..960199268e 100644
--- a/src/Database/Validator/Query/Limit.php
+++ b/src/Database/Validator/Query/Limit.php
@@ -3,17 +3,19 @@
 namespace Utopia\Database\Validator\Query;
 
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 use Utopia\Validator\Numeric;
 use Utopia\Validator\Range;
 
+/**
+ * Validates limit query methods ensuring the value is a positive integer within the allowed range.
+ */
 class Limit extends Base
 {
     protected int $maxLimit;
 
     /**
      * Query constructor
-     *
-     * @param int $maxLimit
      */
     public function __construct(int $maxLimit = PHP_INT_MAX)
     {
@@ -25,37 +27,44 @@ public function __construct(int $maxLimit = PHP_INT_MAX)
      *
      * Returns true if method is limit values are within range.
      *
-     * @param Query $value
-     * @return bool
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof Query) {
+        if (! $value instanceof Query) {
             return false;
         }
 
-        if ($value->getMethod() !== Query::TYPE_LIMIT) {
-            $this->message = 'Invalid query method: ' . $value->getMethod();
+        if ($value->getMethod() !== Method::Limit) {
+            $this->message = 'Invalid query method: '.$value->getMethod()->value;
+
             return false;
         }
 
         $limit = $value->getValue();
 
         $validator = new Numeric();
-        if (!$validator->isValid($limit)) {
-            $this->message = 'Invalid limit: ' . $validator->getDescription();
+        if (! $validator->isValid($limit)) {
+            $this->message = 'Invalid limit: '.$validator->getDescription();
+
             return false;
         }
 
         $validator = new Range(1, $this->maxLimit);
-        if (!$validator->isValid($limit)) {
-            $this->message = 'Invalid limit: ' . $validator->getDescription();
+        if (! $validator->isValid($limit)) {
+            $this->message = 'Invalid limit: '.$validator->getDescription();
+
             return false;
         }
 
         return true;
     }
 
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_LIMIT;
diff --git a/src/Database/Validator/Query/Offset.php b/src/Database/Validator/Query/Offset.php
index 8d59be4d0d..f460d9dadd 100644
--- a/src/Database/Validator/Query/Offset.php
+++ b/src/Database/Validator/Query/Offset.php
@@ -3,15 +3,21 @@
 namespace Utopia\Database\Validator\Query;
 
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 use Utopia\Validator\Numeric;
 use Utopia\Validator\Range;
 
+/**
+ * Validates offset query methods ensuring the value is a non-negative integer within the allowed range.
+ */
 class Offset extends Base
 {
     protected int $maxOffset;
 
     /**
-     * @param int $maxOffset
+     * Create a new offset query validator.
+     *
+     * @param int $maxOffset Maximum allowed offset value
      */
     public function __construct(int $maxOffset = PHP_INT_MAX)
     {
@@ -19,39 +25,49 @@ public function __construct(int $maxOffset = PHP_INT_MAX)
     }
 
     /**
-     * @param Query $value
+     * Validate that the value is a valid offset query within the allowed range.
+     *
+     * @param mixed $value The query to validate
      * @return bool
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof Query) {
+        if (! $value instanceof Query) {
             return false;
         }
 
         $method = $value->getMethod();
 
-        if ($method !== Query::TYPE_OFFSET) {
-            $this->message = 'Query method invalid: ' . $method;
+        if ($method !== Method::Offset) {
+            $this->message = 'Query method invalid: '.$method->value;
+
             return false;
         }
 
         $offset = $value->getValue();
 
         $validator = new Numeric();
-        if (!$validator->isValid($offset)) {
-            $this->message = 'Invalid limit: ' . $validator->getDescription();
+        if (! $validator->isValid($offset)) {
+            $this->message = 'Invalid offset: '.$validator->getDescription();
+
             return false;
         }
 
         $validator = new Range(0, $this->maxOffset);
-        if (!$validator->isValid($offset)) {
-            $this->message = 'Invalid offset: ' . $validator->getDescription();
+        if (! $validator->isValid($offset)) {
+            $this->message = 'Invalid offset: '.$validator->getDescription();
+
             return false;
         }
 
         return true;
     }
 
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_OFFSET;
diff --git a/src/Database/Validator/Query/Order.php b/src/Database/Validator/Query/Order.php
index 5d9970a013..acfde47fa3 100644
--- a/src/Database/Validator/Query/Order.php
+++ b/src/Database/Validator/Query/Order.php
@@ -4,7 +4,11 @@
 
 use Utopia\Database\Document;
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 
+/**
+ * Validates order query methods ensuring referenced attributes exist in the schema.
+ */
 class Order extends Base
 {
     /**
@@ -13,41 +17,69 @@ class Order extends Base
     protected array $schema = [];
 
     /**
-     * @param array<Document> $attributes
-     * @param bool $supportForAttributes
+     * Transient aggregation aliases registered by Queries::isValid for the
+     * current validation pass. Kept separate from $schema so it can be reset
+     * per-call without clobbering the real attribute schema — prior versions
+     * mutated $schema directly, leaking aliases across requests in long-lived
+     * processes (Swoole) and pooled validator instances.
+     *
+     * @var array<string, true>
+     */
+    protected array $aggregationAliases = [];
+
+    /**
+     * @var array<string, true>
+     */
+    protected array $joinAliases = [];
+
+    /**
+     * @param  array<Document>  $attributes
      */
     public function __construct(array $attributes = [], protected bool $supportForAttributes = true)
     {
         foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
+            /** @var string $attrKey */
+            $attrKey = $attribute->getAttribute('key', $attribute->getAttribute(Document::ID));
+            $this->schema[$attrKey] = $attribute->getArrayCopy();
         }
     }
 
-    /**
-     * @param string $attribute
-     * @return bool
-     */
     protected function isValidAttribute(string $attribute): bool
     {
-        if (\str_contains($attribute, '.')) {
+        $dot = \strpos($attribute, '.');
+        if ($dot !== false) {
             // Check for special symbol `.`
             if (isset($this->schema[$attribute])) {
                 return true;
             }
 
+            $alias = \substr($attribute, 0, $dot);
+            $column = \substr($attribute, $dot + 1);
+
+            if (isset($this->joinAliases[$alias]) && $this->isAllowedJoinColumn($column)) {
+                return true;
+            }
+
             // For relationships, just validate the top level.
             // Will validate each nested level during the recursive calls.
-            $attribute = \explode('.', $attribute)[0];
+            $attribute = $alias;
 
             if (isset($this->schema[$attribute])) {
-                $this->message = 'Cannot order by nested attribute: ' . $attribute;
+                $this->message = 'Cannot order by nested attribute: '.$attribute;
+
                 return false;
             }
         }
 
+        // Accept transient aggregation aliases registered by Queries::isValid
+        if (isset($this->aggregationAliases[$attribute])) {
+            return true;
+        }
+
         // Search for attribute in schema
-        if ($this->supportForAttributes && !isset($this->schema[$attribute])) {
-            $this->message = 'Attribute not found in schema: ' . $attribute;
+        if ($this->supportForAttributes && ! isset($this->schema[$attribute])) {
+            $this->message = 'Attribute not found in schema: '.$attribute;
+
             return false;
         }
 
@@ -61,29 +93,77 @@ protected function isValidAttribute(string $attribute): bool
      *
      * Otherwise, returns false
      *
-     * @param Query $value
-     * @return bool
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof Query) {
+        if (! $value instanceof Query) {
             return false;
         }
 
         $method = $value->getMethod();
         $attribute = $value->getAttribute();
 
-        if ($method === Query::TYPE_ORDER_ASC || $method === Query::TYPE_ORDER_DESC) {
+        if ($method === Method::OrderAsc || $method === Method::OrderDesc) {
             return $this->isValidAttribute($attribute);
         }
 
-        if ($method === Query::TYPE_ORDER_RANDOM) {
+        if ($method === Method::OrderRandom) {
             return true; // orderRandom doesn't need an attribute
         }
 
         return false;
     }
 
+    /**
+     * @param array<string> $aliases
+     */
+    public function allowJoinAliases(array $aliases): void
+    {
+        foreach ($aliases as $alias) {
+            if ($alias !== '') {
+                $this->joinAliases[$alias] = true;
+            }
+        }
+    }
+
+    public function resetJoinAliases(): void
+    {
+        $this->joinAliases = [];
+    }
+
+    private function isAllowedJoinColumn(string $column): bool
+    {
+        return $column !== '' && \preg_match('/^[A-Za-z_$][A-Za-z0-9_$]*$/', $column) === 1;
+    }
+
+    /**
+     * Register aggregation aliases that become valid order targets for the
+     * current validation pass. Callers (see Queries::isValid) must invoke
+     * resetAggregationAliases() before the pass to avoid cross-call leakage.
+     *
+     * @param array<string> $aliases
+     */
+    public function addAggregationAliases(array $aliases): void
+    {
+        foreach ($aliases as $alias) {
+            $this->aggregationAliases[$alias] = true;
+        }
+    }
+
+    /**
+     * Clear any aggregation aliases added by a previous validation pass.
+     */
+    public function resetAggregationAliases(): void
+    {
+        $this->aggregationAliases = [];
+    }
+
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_ORDER;
diff --git a/src/Database/Validator/Query/Select.php b/src/Database/Validator/Query/Select.php
index 2df21c9a3c..8fd7c0586d 100644
--- a/src/Database/Validator/Query/Select.php
+++ b/src/Database/Validator/Query/Select.php
@@ -2,10 +2,15 @@
 
 namespace Utopia\Database\Validator\Query;
 
+use Utopia\Database\Attribute;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 
+/**
+ * Validates select query methods ensuring referenced attributes exist in the schema and are not duplicated.
+ */
 class Select extends Base
 {
     /**
@@ -14,27 +19,19 @@ class Select extends Base
     protected array $schema = [];
 
     /**
-     * List of internal attributes
-     *
-     * @var array<string>
+     * @var array<string, true>
      */
-    protected const INTERNAL_ATTRIBUTES = [
-        '$id',
-        '$sequence',
-        '$createdAt',
-        '$updatedAt',
-        '$permissions',
-        '$collection',
-    ];
+    protected array $joinAliases = [];
 
     /**
-     * @param array<Document> $attributes
-     * @param bool $supportForAttributes
+     * @param  array<Document>  $attributes
      */
     public function __construct(array $attributes = [], protected bool $supportForAttributes = true)
     {
         foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
+            /** @var string $attrKey */
+            $attrKey = $attribute->getAttribute('key', $attribute->getAttribute(Document::ID));
+            $this->schema[$attrKey] = $attribute->getArrayCopy();
         }
     }
 
@@ -45,54 +42,67 @@ public function __construct(array $attributes = [], protected bool $supportForAt
      *
      * Otherwise, returns false
      *
-     * @param Query $value
-     * @return bool
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
-        if (!$value instanceof Query) {
+        if (! $value instanceof Query) {
             return false;
         }
 
-        if ($value->getMethod() !== Query::TYPE_SELECT) {
+        if ($value->getMethod() !== Method::Select) {
             return false;
         }
 
         $internalKeys = \array_map(
-            fn ($attr) => $attr['$id'],
-            Database::INTERNAL_ATTRIBUTES
+            fn (Attribute $attr): string => $attr->key,
+            Database::internalAttributes()
         );
 
         if (\count($value->getValues()) === 0) {
             $this->message = 'No attributes selected';
+
             return false;
         }
 
         // Before the duplicate check: array_unique() stringifies every array element
         // to "Array", so two nested values collapse into one and report a misleading
         // duplicate instead of the type error that is actually there.
+        $attributes = [];
         foreach ($value->getValues() as $attribute) {
             if (!\is_string($attribute)) {
                 $this->message = 'Attribute selection must be a string, got ' . \get_debug_type($attribute);
                 return false;
             }
+            $attributes[] = $attribute;
         }
 
-        if (\count($value->getValues()) !== \count(\array_unique($value->getValues()))) {
+        if (\count($attributes) !== \count(\array_unique($attributes))) {
             $this->message = 'Duplicate attributes selected';
+
             return false;
 
         }
-        foreach ($value->getValues() as $attribute) {
-            if (\str_contains($attribute, '.')) {
-                //special symbols with `dots`
+        foreach ($value->getValues() as $attributeValue) {
+            /** @var string $attribute */
+            $attribute = $attributeValue;
+            $dot = \strpos($attribute, '.');
+            if ($dot !== false) {
+                // special symbols with `dots`
                 if (isset($this->schema[$attribute])) {
                     continue;
                 }
 
+                $alias = \substr($attribute, 0, $dot);
+                $column = \substr($attribute, $dot + 1);
+
+                if (isset($this->joinAliases[$alias]) && $this->isAllowedJoinColumn($column)) {
+                    continue;
+                }
+
                 // For relationships, just validate the top level.
                 // Will validate each nested level during the recursive calls.
-                $attribute = \explode('.', $attribute)[0];
+                $attribute = $alias;
             }
 
             // Skip internal attributes
@@ -100,14 +110,43 @@ public function isValid($value): bool
                 continue;
             }
 
-            if ($this->supportForAttributes && !isset($this->schema[$attribute]) && $attribute !== '*') {
-                $this->message = 'Attribute not found in schema: ' . $attribute;
+            if ($this->supportForAttributes && ! isset($this->schema[$attribute]) && $attribute !== '*') {
+                $this->message = 'Attribute not found in schema: '.$attribute;
+
                 return false;
             }
         }
+
         return true;
     }
 
+    /**
+     * @param array<string> $aliases
+     */
+    public function allowJoinAliases(array $aliases): void
+    {
+        foreach ($aliases as $alias) {
+            if ($alias !== '') {
+                $this->joinAliases[$alias] = true;
+            }
+        }
+    }
+
+    public function resetJoinAliases(): void
+    {
+        $this->joinAliases = [];
+    }
+
+    private function isAllowedJoinColumn(string $column): bool
+    {
+        return $column !== '' && \preg_match('/^[A-Za-z_$][A-Za-z0-9_$]*$/', $column) === 1;
+    }
+
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     public function getMethodType(): string
     {
         return self::METHOD_TYPE_SELECT;
diff --git a/src/Database/Validator/Roles.php b/src/Database/Validator/Roles.php
index 91202191ea..f8f254e471 100644
--- a/src/Database/Validator/Roles.php
+++ b/src/Database/Validator/Roles.php
@@ -2,18 +2,28 @@
 
 namespace Utopia\Database\Validator;
 
+use Exception;
 use Utopia\Database\Helpers\Role;
 use Utopia\Validator;
 
+/**
+ * Validates role strings ensuring they use valid role names, identifiers, and dimensions.
+ */
 class Roles extends Validator
 {
     // Roles
     public const ROLE_ANY = 'any';
+
     public const ROLE_GUESTS = 'guests';
+
     public const ROLE_USERS = 'users';
+
     public const ROLE_USER = 'user';
+
     public const ROLE_TEAM = 'team';
+
     public const ROLE_MEMBER = 'member';
+
     public const ROLE_LABEL = 'label';
 
     public const ROLES = [
@@ -64,7 +74,7 @@ class Roles extends Validator
             'dimension' => [
                 'allowed' => true,
                 'required' => false,
-                'options' => self::USER_DIMENSIONS
+                'options' => self::USER_DIMENSIONS,
             ],
         ],
         self::ROLE_USER => [
@@ -75,7 +85,7 @@ class Roles extends Validator
             'dimension' => [
                 'allowed' => true,
                 'required' => false,
-                'options' => self::USER_DIMENSIONS
+                'options' => self::USER_DIMENSIONS,
             ],
         ],
         self::ROLE_TEAM => [
@@ -112,6 +122,7 @@ class Roles extends Validator
 
     // Dimensions
     public const DIMENSION_VERIFIED = 'verified';
+
     public const DIMENSION_UNVERIFIED = 'unverified';
 
     public const USER_DIMENSIONS = [
@@ -122,8 +133,8 @@ class Roles extends Validator
     /**
      * Roles constructor.
      *
-     * @param int $length maximum amount of role. 0 means unlimited.
-     * @param array<string> $allowed allowed roles. Defaults to all available.
+     * @param  int  $length  maximum amount of role. 0 means unlimited.
+     * @param  array<string>  $allowed  allowed roles. Defaults to all available.
      */
     public function __construct(int $length = 0, array $allowed = self::ROLES)
     {
@@ -135,8 +146,6 @@ public function __construct(int $length = 0, array $allowed = self::ROLES)
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -148,33 +157,36 @@ public function getDescription(): string
      *
      * Returns true if valid or false if not.
      *
-     * @param mixed $roles
-     *
-     * @return bool
+     * @param  mixed  $roles
      */
     public function isValid($roles): bool
     {
-        if (!\is_array($roles)) {
+        if (! \is_array($roles)) {
             $this->message = 'Roles must be an array of strings.';
+
             return false;
         }
 
         if ($this->length && \count($roles) > $this->length) {
-            $this->message = 'You can only provide up to ' . $this->length . ' roles.';
+            $this->message = 'You can only provide up to '.$this->length.' roles.';
+
             return false;
         }
 
         foreach ($roles as $role) {
-            if (!\is_string($role)) {
+            if (! \is_string($role)) {
                 $this->message = 'Every role must be of type string.';
+
                 return false;
             }
             if ($role === '*') {
                 $this->message = 'Wildcard role "*" has been replaced. Use "any" instead.';
+
                 return false;
             }
             if (\str_contains($role, 'role:')) {
                 $this->message = 'Roles using the "role:" prefix have been removed. Use "users", "guests", or "any" instead.';
+
                 return false;
             }
 
@@ -185,15 +197,17 @@ public function isValid($roles): bool
                     break;
                 }
             }
-            if (!$isAllowed) {
-                $this->message = 'Role "' . $role . '" is not allowed. Must be one of: ' . \implode(', ', $this->allowed) . '.';
+            if (! $isAllowed) {
+                $this->message = 'Role "'.$role.'" is not allowed. Must be one of: '.\implode(', ', $this->allowed).'.';
+
                 return false;
             }
 
             try {
                 $role = Role::parse($role);
-            } catch (\Exception $e) {
+            } catch (Exception $e) {
                 $this->message = $e->getMessage();
+
                 return false;
             }
 
@@ -201,10 +215,11 @@ public function isValid($roles): bool
             $identifier = $role->getIdentifier();
             $dimension = $role->getDimension();
 
-            if (!$this->isValidRole($roleName, $identifier, $dimension)) {
+            if (! $this->isValidRole($roleName, $identifier, $dimension)) {
                 return false;
             }
         }
+
         return true;
     }
 
@@ -212,8 +227,6 @@ public function isValid($roles): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -224,8 +237,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
@@ -250,7 +261,8 @@ protected function isValidRole(
         $config = self::CONFIG[$role] ?? null;
 
         if (empty($config)) {
-            $this->message = 'Role "' . $role . '" is not allowed. Must be one of: ' . \implode(', ', self::ROLES) . '.';
+            $this->message = 'Role "'.$role.'" is not allowed. Must be one of: '.\implode(', ', self::ROLES).'.';
+
             return false;
         }
 
@@ -259,51 +271,58 @@ protected function isValidRole(
         $required = $config['identifier']['required'];
 
         // Not allowed and has an identifier
-        if (!$allowed && !empty($identifier)) {
-            $this->message = 'Role "' . $role . '"' . ' can not have an ID value.';
+        if (! $allowed && ! empty($identifier)) {
+            $this->message = 'Role "'.$role.'"'.' can not have an ID value.';
+
             return false;
         }
 
         // Required and has no identifier
         if ($allowed && $required && empty($identifier)) {
-            $this->message = 'Role "' . $role . '"' . ' must have an ID value.';
+            $this->message = 'Role "'.$role.'"'.' must have an ID value.';
+
             return false;
         }
 
         // Allowed and has an invalid identifier
-        if ($allowed && !empty($identifier) && !$identifierValidator->isValid($identifier)) {
-            $this->message = 'Role "' . $role . '"' . ' identifier value is invalid: ' . $identifierValidator->getDescription();
+        if ($allowed && ! empty($identifier) && ! $identifierValidator->isValid($identifier)) {
+            $this->message = 'Role "'.$role.'"'.' identifier value is invalid: '.$identifierValidator->getDescription();
+
             return false;
         }
 
         // Process dimension configuration
+        /** @var bool $allowed */
         $allowed = $config['dimension']['allowed'];
+        /** @var bool $required */
         $required = $config['dimension']['required'];
         $options = $config['dimension']['options'] ?? [$dimension];
 
         // Not allowed and has a dimension
-        if (!$allowed && !empty($dimension)) {
-            $this->message = 'Role "' . $role . '"' . ' can not have a dimension value.';
+        if (! $allowed && ! empty($dimension)) {
+            $this->message = 'Role "'.$role.'"'.' can not have a dimension value.';
+
             return false;
         }
 
-        // Required and has no dimension
-        // PHPStan complains because there are currently no dimensions that are required, but there might be in future
-        // @phpstan-ignore-next-line
+        // Required and has no dimension (no current dimensions are required, but this guards future additions)
         if ($allowed && $required && empty($dimension)) {
-            $this->message = 'Role "' . $role . '"' . ' must have a dimension value.';
+            $this->message = 'Role "'.$role.'"'.' must have a dimension value.';
+
             return false;
         }
 
-        if ($allowed && !empty($dimension)) {
+        if ($allowed && ! empty($dimension)) {
             // Allowed and dimension is not an allowed option
-            if (!\in_array($dimension, $options)) {
-                $this->message = 'Role "' . $role . '"' . ' dimension value is invalid. Must be one of: ' . \implode(', ', $options) . '.';
+            if (! \in_array($dimension, $options)) {
+                $this->message = 'Role "'.$role.'"'.' dimension value is invalid. Must be one of: '.\implode(', ', $options).'.';
+
                 return false;
             }
             // Allowed and dimension is not a valid key
-            if (!$dimensionValidator->isValid($dimension)) {
-                $this->message = 'Role "' . $role . '"' . ' dimension value is invalid: ' . $dimensionValidator->getDescription();
+            if (! $dimensionValidator->isValid($dimension)) {
+                $this->message = 'Role "'.$role.'"'.' dimension value is invalid: '.$dimensionValidator->getDescription();
+
                 return false;
             }
         }
diff --git a/src/Database/Validator/Sequence.php b/src/Database/Validator/Sequence.php
index 7e3ebca271..9a06a6540c 100644
--- a/src/Database/Validator/Sequence.php
+++ b/src/Database/Validator/Sequence.php
@@ -3,14 +3,24 @@
 namespace Utopia\Database\Validator;
 
 use Utopia\Database\Database;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator;
 use Utopia\Validator\Range;
 
+/**
+ * Validates sequence/ID values based on the configured ID attribute type (UUID7 or integer).
+ */
 class Sequence extends Validator
 {
     private string $idAttributeType;
+
     private bool $primary;
 
+    /**
+     * Get the validator description.
+     *
+     * @return string
+     */
     public function getDescription(): string
     {
         return 'Invalid sequence value';
@@ -25,16 +35,32 @@ public function __construct(string $idAttributeType, bool $primary)
         $this->idAttributeType = $idAttributeType;
     }
 
+    /**
+     * Is array.
+     *
+     * @return bool
+     */
     public function isArray(): bool
     {
         return false;
     }
 
+    /**
+     * Get the validator type.
+     *
+     * @return string
+     */
     public function getType(): string
     {
         return self::TYPE_STRING;
     }
 
+    /**
+     * Validate a sequence value against the configured ID attribute type.
+     *
+     * @param mixed $value The value to validate
+     * @return bool
+     */
     public function isValid($value): bool
     {
         if ($this->primary && empty($value)) {
@@ -45,23 +71,20 @@ public function isValid($value): bool
             return true;
         }
 
-        if (!\is_string($value) && !\is_int($value)) {
+        if (! \is_string($value) && ! \is_int($value)) {
             return false;
         }
 
-        if (!$this->primary) {
+        if (! $this->primary) {
             return true;
         }
 
-        switch ($this->idAttributeType) {
-            case Database::VAR_UUID7:
-                return \is_string($value) && preg_match('/^[a-f0-9]{8}-[a-f0-9]{4}-7[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i', $value) === 1;
-            case Database::VAR_INTEGER:
-                $validator = new Range(1, Database::MAX_BIG_INT, Database::VAR_INTEGER);
-                return $validator->isValid($value);
+        $idType = ColumnType::tryFrom($this->idAttributeType);
 
-            default:
-                return false;
-        }
+        return match ($idType) {
+            ColumnType::Uuid7 => \is_string($value) && preg_match('/^[a-f0-9]{8}-[a-f0-9]{4}-7[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i', $value) === 1,
+            ColumnType::Integer => (new Range(1, Database::MAX_BIG_INT, ColumnType::Integer->value))->isValid($value),
+            default => false,
+        };
     }
 }
diff --git a/src/Database/Validator/Spatial.php b/src/Database/Validator/Spatial.php
index 912f05b2b2..41533ea217 100644
--- a/src/Database/Validator/Spatial.php
+++ b/src/Database/Validator/Spatial.php
@@ -2,14 +2,23 @@
 
 namespace Utopia\Database\Validator;
 
-use Utopia\Database\Database;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator;
 
+/**
+ * Validates spatial data (point, linestring, polygon) as arrays or WKT strings with coordinate range checking.
+ */
 class Spatial extends Validator
 {
     private string $spatialType;
+
     protected string $message = '';
 
+    /**
+     * Create a new spatial validator for the given type.
+     *
+     * @param string $spatialType The spatial type to validate (point, linestring, polygon)
+     */
     public function __construct(string $spatialType)
     {
         $this->spatialType = $spatialType;
@@ -18,50 +27,54 @@ public function __construct(string $spatialType)
     /**
      * Validate POINT data
      *
-     * @param array<mixed> $value
-     * @return bool
+     * @param  array<mixed>  $value
      */
     protected function validatePoint(array $value): bool
     {
         if (count($value) !== 2) {
             $this->message = 'Point must be an array of two numeric values [x, y]';
+
             return false;
         }
 
-        if (!is_numeric($value[0]) || !is_numeric($value[1])) {
+        if (! is_numeric($value[0]) || ! is_numeric($value[1])) {
             $this->message = 'Point coordinates must be numeric values';
+
             return false;
         }
 
-        return $this->isValidCoordinate((float)$value[0], (float) $value[1]);
+        return $this->isValidCoordinate((float) $value[0], (float) $value[1]);
     }
 
     /**
      * Validate LINESTRING data
      *
-     * @param array<mixed> $value
-     * @return bool
+     * @param  array<mixed>  $value
      */
     protected function validateLineString(array $value): bool
     {
         if (count($value) < 2) {
             $this->message = 'LineString must contain at least two points';
+
             return false;
         }
 
         foreach ($value as $pointIndex => $point) {
-            if (!is_array($point) || count($point) !== 2) {
+            if (! is_array($point) || count($point) !== 2) {
                 $this->message = 'Each point in LineString must be an array of two values [x, y]';
+
                 return false;
             }
 
-            if (!is_numeric($point[0]) || !is_numeric($point[1])) {
+            if (! is_numeric($point[0]) || ! is_numeric($point[1])) {
                 $this->message = 'Each point in LineString must have numeric coordinates';
+
                 return false;
             }
 
-            if (!$this->isValidCoordinate((float)$point[0], (float)$point[1])) {
+            if (! $this->isValidCoordinate((float) $point[0], (float) $point[1])) {
                 $this->message = "Invalid coordinates at point #{$pointIndex}: {$this->message}";
+
                 return false;
             }
         }
@@ -72,13 +85,13 @@ protected function validateLineString(array $value): bool
     /**
      * Validate POLYGON data
      *
-     * @param array<mixed> $value
-     * @return bool
+     * @param  array<mixed>  $value
      */
     protected function validatePolygon(array $value): bool
     {
         if (empty($value)) {
             $this->message = 'Polygon must contain at least one ring';
+
             return false;
         }
 
@@ -92,29 +105,34 @@ protected function validatePolygon(array $value): bool
         }
 
         foreach ($value as $ringIndex => $ring) {
-            if (!is_array($ring) || empty($ring)) {
+            if (! is_array($ring) || empty($ring)) {
                 $this->message = "Ring #{$ringIndex} must be an array of points";
+
                 return false;
             }
 
             if (count($ring) < 4) {
                 $this->message = "Ring #{$ringIndex} must contain at least 4 points to form a closed polygon";
+
                 return false;
             }
 
             foreach ($ring as $pointIndex => $point) {
-                if (!is_array($point) || count($point) !== 2) {
+                if (! is_array($point) || count($point) !== 2) {
                     $this->message = "Point #{$pointIndex} in ring #{$ringIndex} must be an array of two values [x, y]";
+
                     return false;
                 }
 
-                if (!is_numeric($point[0]) || !is_numeric($point[1])) {
+                if (! is_numeric($point[0]) || ! is_numeric($point[1])) {
                     $this->message = "Coordinates of point #{$pointIndex} in ring #{$ringIndex} must be numeric";
+
                     return false;
                 }
 
-                if (!$this->isValidCoordinate((float)$point[0], (float)$point[1])) {
+                if (! $this->isValidCoordinate((float) $point[0], (float) $point[1])) {
                     $this->message = "Invalid coordinates at point #{$pointIndex} in ring #{$ringIndex}: {$this->message}";
+
                     return false;
                 }
             }
@@ -122,6 +140,7 @@ protected function validatePolygon(array $value): bool
             // Check that the ring is closed (first point == last point)
             if ($ring[0] !== $ring[count($ring) - 1]) {
                 $this->message = "Ring #{$ringIndex} must be closed (first point must equal last point)";
+
                 return false;
             }
         }
@@ -130,36 +149,63 @@ protected function validatePolygon(array $value): bool
     }
 
     /**
-     * Check if a value is valid WKT string
+     * Check if a value is a valid WKT (Well-Known Text) string.
+     *
+     * @param string $value The string to check
+     * @return bool
      */
     public static function isWKTString(string $value): bool
     {
         $value = trim($value);
+
         return (bool) preg_match('/^(POINT|LINESTRING|POLYGON)\s*\(/i', $value);
     }
 
+    /**
+     * Get the validator description including the error message.
+     *
+     * @return string
+     */
     public function getDescription(): string
     {
-        return 'Value must be a valid ' . $this->spatialType . ": {$this->message}";
+        return 'Value must be a valid '.$this->spatialType.": {$this->message}";
     }
 
+    /**
+     * Is array.
+     *
+     * @return bool
+     */
     public function isArray(): bool
     {
         return false;
     }
 
+    /**
+     * Get the validator type.
+     *
+     * @return string
+     */
     public function getType(): string
     {
         return self::TYPE_ARRAY;
     }
 
+    /**
+     * Get the spatial type this validator handles.
+     *
+     * @return string
+     */
     public function getSpatialType(): string
     {
         return $this->spatialType;
     }
 
     /**
-     * Main validation entrypoint
+     * Validate a spatial value as an array of coordinates or a WKT string.
+     *
+     * @param mixed $value The spatial data to validate
+     * @return bool
      */
     public function isValid($value): bool
     {
@@ -172,23 +218,26 @@ public function isValid($value): bool
         }
 
         if (is_array($value)) {
-            switch ($this->spatialType) {
-                case Database::VAR_POINT:
+            $spatialColumnType = ColumnType::tryFrom($this->spatialType);
+            switch ($spatialColumnType) {
+                case ColumnType::Point:
                     return $this->validatePoint($value);
 
-                case Database::VAR_LINESTRING:
+                case ColumnType::Linestring:
                     return $this->validateLineString($value);
 
-                case Database::VAR_POLYGON:
+                case ColumnType::Polygon:
                     return $this->validatePolygon($value);
 
                 default:
-                    $this->message = 'Unknown spatial type: ' . $this->spatialType;
+                    $this->message = 'Unknown spatial type: '.$this->spatialType;
+
                     return false;
             }
         }
 
         $this->message = 'Spatial value must be array or WKT string';
+
         return false;
     }
 
@@ -196,11 +245,13 @@ private function isValidCoordinate(int|float $x, int|float $y): bool
     {
         if ($x < -180 || $x > 180) {
             $this->message = "Longitude (x) must be between -180 and 180, got {$x}";
+
             return false;
         }
 
         if ($y < -90 || $y > 90) {
             $this->message = "Latitude (y) must be between -90 and 90, got {$y}";
+
             return false;
         }
 
diff --git a/src/Database/Validator/Structure.php b/src/Database/Validator/Structure.php
index 4e3f66ec4b..627038f76b 100644
--- a/src/Database/Validator/Structure.php
+++ b/src/Database/Validator/Structure.php
@@ -3,13 +3,16 @@
 namespace Utopia\Database\Validator;
 
 use Closure;
+use DateTime;
 use Exception;
+use Utopia\Database\Attribute;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Operator;
 use Utopia\Database\Validator\Datetime as DatetimeValidator;
 use Utopia\Database\Validator\Operator as OperatorValidator;
+use Utopia\Query\Schema\ColumnType;
 use Utopia\Validator;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\FloatValidator;
@@ -17,6 +20,9 @@
 use Utopia\Validator\Range;
 use Utopia\Validator\Text;
 
+/**
+ * Validates document structure against collection schema including required attributes, types, and formats.
+ */
 class Structure extends Validator
 {
     /**
@@ -24,8 +30,8 @@ class Structure extends Validator
      */
     protected array $attributes = [
         [
-            '$id' => '$id',
-            'type' => Database::VAR_STRING,
+            Document::ID => Document::ID,
+            'type' => 'string',
             'size' => 255,
             'required' => false,
             'signed' => true,
@@ -33,8 +39,8 @@ class Structure extends Validator
             'filters' => [],
         ],
         [
-            '$id' => '$sequence',
-            'type' => Database::VAR_ID,
+            Document::ID => Document::SEQUENCE,
+            'type' => 'id',
             'size' => 0,
             'required' => false,
             'signed' => true,
@@ -42,8 +48,8 @@ class Structure extends Validator
             'filters' => [],
         ],
         [
-            '$id' => '$collection',
-            'type' => Database::VAR_STRING,
+            Document::ID => Document::COLLECTION,
+            'type' => 'string',
             'size' => 255,
             'required' => true,
             'signed' => true,
@@ -51,8 +57,8 @@ class Structure extends Validator
             'filters' => [],
         ],
         [
-            '$id' => '$tenant',
-            'type' => Database::VAR_ID,
+            Document::ID => Document::TENANT,
+            'type' => 'id',
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -61,17 +67,17 @@ class Structure extends Validator
             'filters' => [],
         ],
         [
-            '$id' => '$permissions',
-            'type' => Database::VAR_STRING,
-            'size' => 67000, // medium text
+            Document::ID => Document::PERMISSIONS,
+            'type' => 'string',
+            'size' => 67000,
             'required' => false,
             'signed' => true,
             'array' => true,
             'filters' => [],
         ],
         [
-            '$id' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::CREATED_AT,
+            'type' => 'datetime',
             'size' => 0,
             'required' => true,
             'signed' => false,
@@ -79,14 +85,24 @@ class Structure extends Validator
             'filters' => [],
         ],
         [
-            '$id' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            Document::ID => Document::UPDATED_AT,
+            'type' => 'datetime',
             'size' => 0,
             'required' => true,
             'signed' => false,
             'array' => false,
             'filters' => [],
-        ]
+        ],
+        [
+            Document::ID => Document::VERSION,
+            'type' => 'integer',
+            'size' => 0,
+            'required' => false,
+            'default' => null,
+            'signed' => false,
+            'array' => false,
+            'filters' => [],
+        ],
     ];
 
     /**
@@ -94,20 +110,29 @@ class Structure extends Validator
      */
     protected static array $formats = [];
 
+    protected string $message = 'General Error';
+
     /**
-     * @var string
+     * Lazily-built merged attribute list (internal + collection).
+     *
+     * Cached for the lifetime of this validator. `$collection` is `readonly`
+     * (the property cannot be reassigned), but its inner Document state is
+     * not deep-frozen — callers that mutate `$collection->setAttribute(
+     * 'attributes', ...)` between `isValid()` calls would see a stale memo.
+     * Construct a fresh validator if the underlying schema may change.
+     *
+     * @var array<array<string, mixed>|Document>|null
      */
-    protected string $message = 'General Error';
+    private ?array $mergedAttributes = null;
 
     /**
      * Structure constructor.
-     *
      */
     public function __construct(
         protected readonly Document $collection,
         private readonly string $idAttributeType,
-        private readonly \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
-        private readonly \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
+        private readonly DateTime $minAllowedDate = new DateTime('0000-01-01'),
+        private readonly DateTime $maxAllowedDate = new DateTime('9999-12-31'),
         private bool $supportForAttributes = true,
         private readonly bool $supportUnsignedBigInt = true,
         private readonly ?Document $currentDocument = null
@@ -128,28 +153,23 @@ public static function getFormats(): array
      * Add a new Validator
      * Stores a callback and required params to create Validator
      *
-     * @param string $name
-     * @param Closure $callback Callback that accepts $params in order and returns \Utopia\Validator
-     * @param string $type Primitive data type for validation
+     * @param  Closure(array<string, mixed>): Validator  $callback
+     * @param  ColumnType  $type  Primitive data type for validation
      */
-    public static function addFormat(string $name, Closure $callback, string $type): void
+    public static function addFormat(string $name, Closure $callback, ColumnType $type): void
     {
         self::$formats[$name] = [
             'callback' => $callback,
-            'type' => $type,
+            'type' => $type->value,
         ];
     }
 
     /**
      * Check if validator has been added
-     *
-     * @param string $name
-     *
-     * @return bool
      */
-    public static function hasFormat(string $name, string $type): bool
+    public static function hasFormat(string $name, ColumnType $type): bool
     {
-        if (isset(self::$formats[$name]) && self::$formats[$name]['type'] === $type) {
+        if (isset(self::$formats[$name]) && self::$formats[$name]['type'] === $type->value) {
             return true;
         }
 
@@ -159,17 +179,16 @@ public static function hasFormat(string $name, string $type): bool
     /**
      * Get a Format array to create Validator
      *
-     * @param string $name
-     * @param string $type
      *
      * @return array{callback: callable, type: string}
+     *
      * @throws Exception
      */
-    public static function getFormat(string $name, string $type): array
+    public static function getFormat(string $name, ColumnType $type): array
     {
         if (isset(self::$formats[$name])) {
-            if (self::$formats[$name]['type'] !== $type) {
-                throw new DatabaseException('Format "'.$name.'" not available for attribute type "'.$type.'"');
+            if (self::$formats[$name]['type'] !== $type->value) {
+                throw new DatabaseException('Format "'.$name.'" not available for attribute type "'.$type->value.'"');
             }
 
             return self::$formats[$name];
@@ -180,8 +199,6 @@ public static function getFormat(string $name, string $type): array
 
     /**
      * Remove a Validator
-     *
-     * @param string $name
      */
     public static function removeFormat(string $name): void
     {
@@ -192,8 +209,6 @@ public static function removeFormat(string $name): void
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -205,40 +220,48 @@ public function getDescription(): string
      *
      * Returns true if valid or false if not.
      *
-     * @param mixed $document
-     *
-     * @return bool
+     * @param  mixed  $document
      */
     public function isValid($document): bool
     {
-        if (!$document instanceof Document) {
+        if (! $document instanceof Document) {
             $this->message = 'Value must be an instance of Document';
+
             return false;
         }
 
         if (empty($document->getCollection())) {
-            $this->message = 'Missing collection attribute $collection';
+            $this->message = 'Missing collection attribute '.Document::COLLECTION;
+
             return false;
         }
 
-        if (empty($this->collection->getId()) || Database::METADATA !== $this->collection->getCollection()) {
+        if (empty($this->collection->getId()) || $this->collection->getCollection() !== Database::METADATA) {
             $this->message = 'Collection not found';
+
             return false;
         }
 
         $keys = [];
         $structure = $document->getArrayCopy();
-        $attributes = \array_merge($this->attributes, $this->collection->getAttribute('attributes', []));
+        if ($this->mergedAttributes === null) {
+            /** @var array<array<string, mixed>|Document> $collectionAttributes */
+            $collectionAttributes = $this->collection->getAttribute('attributes', []);
+            /** @var array<array<string, mixed>|Document> $merged */
+            $merged = \array_merge($this->attributes, $collectionAttributes);
+            $this->mergedAttributes = $merged;
+        }
+        $attributes = $this->mergedAttributes;
 
-        if (!$this->checkForAllRequiredValues($structure, $attributes, $keys)) {
+        if (! $this->checkForAllRequiredValues($structure, $attributes, $keys)) {
             return false;
         }
 
-        if (!$this->checkForUnknownAttributes($structure, $keys)) {
+        if (! $this->checkForUnknownAttributes($structure, $keys)) {
             return false;
         }
 
-        if (!$this->checkForInvalidAttributeValues($document, $structure, $keys)) {
+        if (! $this->checkForInvalidAttributeValues($document, $structure, $keys)) {
             return false;
         }
 
@@ -248,26 +271,26 @@ public function isValid($document): bool
     /**
      * Check for all required values
      *
-     * @param array<string, mixed> $structure
-     * @param array<string, mixed> $attributes
-     * @param array<string, mixed> $keys
-     *
-     * @return bool
+     * @param  array<string, mixed>  $structure
+     * @param  array<array<string, mixed>|Document>  $attributes
+     * @param  array<string, array<string, mixed>|Document>  $keys
      */
     protected function checkForAllRequiredValues(array $structure, array $attributes, array &$keys): bool
     {
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
 
         foreach ($attributes as $attribute) { // Check all required attributes are set
-            $name = $attribute['$id'] ?? '';
+            /** @var string $name */
+            $name = $attribute[Document::ID] ?? '';
             $required = $attribute['required'] ?? false;
 
             $keys[$name] = $attribute; // List of allowed attributes to help find unknown ones
 
-            if ($required && !isset($structure[$name])) {
+            if ($required && ! isset($structure[$name])) {
                 $this->message = 'Missing required attribute "'.$name.'"';
+
                 return false;
             }
         }
@@ -278,19 +301,18 @@ protected function checkForAllRequiredValues(array $structure, array $attributes
     /**
      * Check for Unknown Attributes
      *
-     * @param array<string, mixed> $structure
-     * @param array<string, mixed> $keys
-     *
-     * @return bool
+     * @param  array<string, mixed>  $structure
+     * @param  array<string, array<string, mixed>|Document>  $keys
      */
     protected function checkForUnknownAttributes(array $structure, array $keys): bool
     {
-        if (!$this->supportForAttributes) {
+        if (! $this->supportForAttributes) {
             return true;
         }
         foreach ($structure as $key => $value) {
-            if (!array_key_exists($key, $keys)) { // Check no unknown attributes are set
+            if (! array_key_exists($key, $keys)) { // Check no unknown attributes are set
                 $this->message = 'Unknown attribute: "'.$key.'"';
+
                 return false;
             }
         }
@@ -301,46 +323,56 @@ protected function checkForUnknownAttributes(array $structure, array $keys): boo
     /**
      * Check for invalid attribute values
      *
-     * @param array<string, mixed> $structure
-     * @param array<string, mixed> $keys
-     *
-     * @return bool
+     * @param  array<string, mixed>  $structure
+     * @param  array<string, array<string, mixed>|Document>  $keys
      */
     protected function checkForInvalidAttributeValues(Document $document, array $structure, array $keys): bool
     {
         foreach ($structure as $key => $value) {
             if (Operator::isOperator($value)) {
                 // Set the attribute name on the operator for validation
+                /** @var Operator $value */
                 $value->setAttribute($key);
 
-                $operatorValidator = new OperatorValidator($this->collection, $this->currentDocument);
-                if (!$operatorValidator->isValid($value)) {
+                $operatorValidator = new OperatorValidator(
+                    $this->collection,
+                    $this->currentDocument,
+                    $this->supportUnsignedBigInt,
+                );
+                if (! $operatorValidator->isValid($value)) {
                     $this->message = $operatorValidator->getDescription();
+
                     return false;
                 }
+
                 continue;
             }
 
             $attribute = $keys[$key] ?? [];
+            /** @var string $type */
             $type = $attribute['type'] ?? '';
             $array = $attribute['array'] ?? false;
+            /** @var string $format */
             $format = $attribute['format'] ?? '';
             $required = $attribute['required'] ?? false;
+            /** @var int $size */
             $size = $attribute['size'] ?? 0;
-            $signed = $attribute['signed'] ?? true;
+            $signed = (bool) ($attribute['signed'] ?? true);
 
             if ($required === false && is_null($value)) { // Allow null value to optional params
                 continue;
             }
 
-            if ($type === Database::VAR_RELATIONSHIP) {
+            $columnType = Attribute::tryNormalizeType($type);
+
+            if ($columnType === ColumnType::Relationship) {
                 continue;
             }
 
             // BIGINT accepts both PHP int and numeric strings.
             // If the numeric string is within PHP's int range, normalize it to an int
             // so downstream code gets a numeric value without precision loss.
-            if ($type === Database::VAR_BIGINT && \is_string($value) && BigInt::fitsPhpInt($value, $signed)) {
+            if (\in_array($columnType, [ColumnType::BigInteger, ColumnType::BigSerial], true) && \is_string($value) && BigInt::fitsPhpInt($value, $signed)) {
                 $normalized = (int)$value;
                 $document->setAttribute($key, $normalized);
                 $value = $normalized;
@@ -348,83 +380,88 @@ protected function checkForInvalidAttributeValues(Document $document, array $str
 
             $validators = [];
 
-            switch ($type) {
-                case Database::VAR_ID:
-                    $validators[] = new Sequence($this->idAttributeType, $attribute['$id'] === '$sequence');
+            switch ($columnType) {
+                case ColumnType::Id:
+                    $validators[] = new Sequence($this->idAttributeType, ($attribute[Document::ID] ?? '') === Document::SEQUENCE);
                     break;
 
-                case Database::VAR_TEXT:
+                case ColumnType::Text:
                     $validators[] = new ByteLength($size);
                     $validators[] = new ByteLength(Database::MAX_TEXT_BYTES);
                     break;
 
-                case Database::VAR_MEDIUMTEXT:
+                case ColumnType::MediumText:
                     $validators[] = new ByteLength($size);
                     $validators[] = new ByteLength(Database::MAX_MEDIUMTEXT_BYTES);
                     break;
 
-                case Database::VAR_LONGTEXT:
+                case ColumnType::LongText:
                     $validators[] = new ByteLength($size);
                     $validators[] = new ByteLength(Database::MAX_LONGTEXT_BYTES);
                     break;
 
-                case Database::VAR_VARCHAR:
-                case Database::VAR_STRING:
+                case ColumnType::Varchar:
+                case ColumnType::String:
                     $validators[] = new Text($size, min: 0);
                     break;
 
-                case Database::VAR_INTEGER:
+                case ColumnType::Integer:
                     // Determine bit size based on attribute size in bytes
                     // BIGINT is always 64-bit in SQL adapters; VAR_INTEGER uses size to decide.
                     $bits =  $size >= 8 ? 64 : 32;
                     // For 64-bit unsigned, use signed since PHP doesn't support true 64-bit unsigned
                     // The Range validator will restrict to positive values only
-                    $unsigned = !$signed && $bits < 64;
+                    $unsigned = ! $signed && $bits < 64;
                     $validators[] = new Integer(false, $bits, $unsigned);
                     $max = $bits === 64 ? Database::MAX_BIG_INT : Database::MAX_INT;
                     $min = $signed ? -$max : 0;
-                    $validators[] = new Range($min, $max, Database::VAR_INTEGER);
+                    $validators[] = new Range($min, $max, ColumnType::Integer->value);
                     break;
 
-                case Database::VAR_BIGINT:
+                case ColumnType::BigInteger:
+                case ColumnType::BigSerial:
                     $validators[] = new BigInt($signed, $this->supportUnsignedBigInt);
                     break;
 
-                case Database::VAR_FLOAT:
+                case ColumnType::Float:
+                case ColumnType::Double:
                     // We need both Float and Range because Range implicitly casts non-numeric values
                     $validators[] = new FloatValidator();
                     $min = $signed ? -Database::MAX_DOUBLE : 0;
-                    $validators[] =  new Range($min, Database::MAX_DOUBLE, Database::VAR_FLOAT);
+                    $validators[] = new Range($min, Database::MAX_DOUBLE, ColumnType::Double->value);
                     break;
 
-                case Database::VAR_BOOLEAN:
+                case ColumnType::Boolean:
                     $validators[] = new Boolean();
                     break;
 
-                case Database::VAR_DATETIME:
+                case ColumnType::Datetime:
                     $validators[] = new DatetimeValidator(
                         min: $this->minAllowedDate,
                         max: $this->maxAllowedDate
                     );
                     break;
 
-                case Database::VAR_OBJECT:
+                case ColumnType::Object:
                     $validators[] = new ObjectValidator();
                     break;
 
-                case Database::VAR_POINT:
-                case Database::VAR_LINESTRING:
-                case Database::VAR_POLYGON:
+                case ColumnType::Point:
+                case ColumnType::Linestring:
+                case ColumnType::Polygon:
                     $validators[] = new Spatial($type);
                     break;
 
-                case Database::VAR_VECTOR:
-                    $validators[] = new Vector($attribute['size'] ?? 0);
+                case ColumnType::Vector:
+                    /** @var int $vectorSize */
+                    $vectorSize = $attribute['size'] ?? 0;
+                    $validators[] = new Vector($vectorSize);
                     break;
 
                 default:
                     if ($this->supportForAttributes) {
                         $this->message = 'Unknown attribute type "'.$type.'"';
+
                         return false;
                     }
             }
@@ -434,36 +471,44 @@ protected function checkForInvalidAttributeValues(Document $document, array $str
 
             if ($format) {
                 // Format encoded as json string containing format name and relevant format options
-                $format = self::getFormat($format, $type);
-                $validators[] = $format['callback']($attribute);
+                $formatDef = self::getFormat($format, Attribute::normalizeType($type));
+                $formatAttribute = $attribute instanceof Document
+                    ? $attribute->getArrayCopy()
+                    : $attribute;
+                /** @var Validator $formatValidator */
+                $formatValidator = $formatDef['callback']($formatAttribute);
+                $validators[] = $formatValidator;
             }
 
             if ($array) { // Validate attribute type for arrays - format for arrays handled separately
-                if (!$required && ((is_array($value) && empty($value)) || is_null($value))) { // Allow both null and [] for optional arrays
+                if (! $required && ((is_array($value) && empty($value)) || is_null($value))) { // Allow both null and [] for optional arrays
                     continue;
                 }
 
-                if (!\is_array($value) || !\array_is_list($value)) {
+                if (! \is_array($value) || ! \array_is_list($value)) {
                     $this->message = 'Attribute "'.$key.'" must be an array';
+
                     return false;
                 }
 
                 foreach ($value as $x => $child) {
-                    if (!$required && is_null($child)) { // Allow null value to optional params
+                    if (! $required && is_null($child)) { // Allow null value to optional params
                         continue;
                     }
 
                     foreach ($validators as $validator) {
-                        if (!$validator->isValid($child)) {
+                        if (! $validator->isValid($child)) {
                             $this->message = 'Attribute "'.$key.'[\''.$x.'\']" has invalid '.$label.'. '.$validator->getDescription();
+
                             return false;
                         }
                     }
                 }
             } else {
                 foreach ($validators as $validator) {
-                    if (!$validator->isValid($value)) {
+                    if (! $validator->isValid($value)) {
                         $this->message = 'Attribute "'.$key.'" has invalid '.$label.'. '.$validator->getDescription();
+
                         return false;
                     }
                 }
@@ -477,8 +522,6 @@ protected function checkForInvalidAttributeValues(Document $document, array $str
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -489,8 +532,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/UID.php b/src/Database/Validator/UID.php
index 743adbcde1..2014a90972 100644
--- a/src/Database/Validator/UID.php
+++ b/src/Database/Validator/UID.php
@@ -4,6 +4,9 @@
 
 use Utopia\Database\Database;
 
+/**
+ * Validates unique identifier strings with alphanumeric chars, underscores, hyphens, and periods.
+ */
 class UID extends Key
 {
     /**
@@ -18,11 +21,9 @@ public function __construct(int $maxLength = Database::MAX_UID_DEFAULT_LENGTH)
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
-        return 'UID must contain at most ' . $this->maxLength . ' chars. Valid chars are a-z, A-Z, 0-9, and underscore. Can\'t start with a leading underscore';
+        return 'UID must contain at most '.$this->maxLength.' chars. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can\'t start with a leading period, hyphen, or underscore';
     }
 }
diff --git a/src/Database/Validator/Vector.php b/src/Database/Validator/Vector.php
index b81d0b3aa7..b2b4007f5a 100644
--- a/src/Database/Validator/Vector.php
+++ b/src/Database/Validator/Vector.php
@@ -4,6 +4,9 @@
 
 use Utopia\Validator;
 
+/**
+ * Validates vector values ensuring they are numeric arrays of the expected dimension size.
+ */
 class Vector extends Validator
 {
     protected int $size;
@@ -11,7 +14,7 @@ class Vector extends Validator
     /**
      * Vector constructor.
      *
-     * @param int $size The size (number of elements) the vector should have
+     * @param  int  $size  The size (number of elements) the vector should have
      */
     public function __construct(int $size)
     {
@@ -22,8 +25,6 @@ public function __construct(int $size)
      * Get Description
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -34,25 +35,22 @@ public function getDescription(): string
      * Is valid
      *
      * Validation will pass when $value is a valid vector array or JSON string
-     *
-     * @param mixed $value
-     * @return bool
      */
     public function isValid(mixed $value): bool
     {
         if (is_string($value)) {
             $decoded = json_decode($value, true);
-            if (!is_array($decoded)) {
+            if (! is_array($decoded)) {
                 return false;
             }
             $value = $decoded;
         }
 
-        if (!is_array($value)) {
+        if (! is_array($value)) {
             return false;
         }
 
-        if (!\array_is_list($value)) {
+        if (! \array_is_list($value)) {
             return false;
         }
 
@@ -62,7 +60,7 @@ public function isValid(mixed $value): bool
 
         // Check that all values are int or float (not strings, booleans, null, arrays, objects)
         foreach ($value as $component) {
-            if (!\is_int($component) && !\is_float($component)) {
+            if (! \is_int($component) && ! \is_float($component)) {
                 return false;
             }
         }
@@ -74,8 +72,6 @@ public function isValid(mixed $value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -86,8 +82,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/stubs/Swoole/Database/DetectsLostConnections.stub.php b/stubs/Swoole/Database/DetectsLostConnections.stub.php
new file mode 100644
index 0000000000..4070b4f036
--- /dev/null
+++ b/stubs/Swoole/Database/DetectsLostConnections.stub.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Swoole\Database;
+
+use Throwable;
+
+class DetectsLostConnections
+{
+    public static function causedByLostConnection(Throwable $error): bool
+    {
+    }
+}
diff --git a/stubs/Swoole/Database/PDOProxy.stub.php b/stubs/Swoole/Database/PDOProxy.stub.php
new file mode 100644
index 0000000000..87c46025bb
--- /dev/null
+++ b/stubs/Swoole/Database/PDOProxy.stub.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace Swoole\Database;
+
+use PDO;
+
+/**
+ * @mixin PDO
+ */
+class PDOProxy
+{
+    /** @param callable(): PDO $constructor */
+    public function __construct(callable $constructor)
+    {
+    }
+
+    /** @param array<mixed> $arguments */
+    public function __call(string $name, array $arguments): mixed
+    {
+    }
+
+    public function __getObject(): PDO
+    {
+    }
+
+    public function beginTransaction(): bool
+    {
+    }
+
+    public function commit(): bool
+    {
+    }
+
+    public function exec(string $statement): int|false
+    {
+    }
+
+    public function getAttribute(int $attribute): mixed
+    {
+    }
+
+    public function getRound(): int
+    {
+    }
+
+    public function inTransaction(): bool
+    {
+    }
+
+    public function lastInsertId(?string $name = null): string|false
+    {
+    }
+
+    /** @param array<int, mixed> $options */
+    public function prepare(string $query, array $options = []): PDOStatementProxy|false
+    {
+    }
+
+    public function query(string $query, ?int $fetchMode = null, mixed ...$fetchModeArgs): PDOStatementProxy|false
+    {
+    }
+
+    public function quote(string $string, int $type = PDO::PARAM_STR): string|false
+    {
+    }
+
+    public function reconnect(): void
+    {
+    }
+
+    public function reset(): void
+    {
+    }
+
+    public function rollBack(): bool
+    {
+    }
+
+    public function setAttribute(int $attribute, mixed $value): bool
+    {
+    }
+}
diff --git a/stubs/Swoole/Database/PDOStatementProxy.stub.php b/stubs/Swoole/Database/PDOStatementProxy.stub.php
new file mode 100644
index 0000000000..a5ceddd97f
--- /dev/null
+++ b/stubs/Swoole/Database/PDOStatementProxy.stub.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace Swoole\Database;
+
+use PDO;
+use PDOStatement;
+
+/**
+ * @mixin PDOStatement
+ */
+class PDOStatementProxy
+{
+    public string $queryString;
+
+    public function __construct(PDOStatement $statement, PDOProxy $parent)
+    {
+    }
+
+    /** @param array<mixed> $arguments */
+    public function __call(string $name, array $arguments): mixed
+    {
+    }
+
+    public function bindColumn(
+        int|string $column,
+        mixed &$variable,
+        int $type = PDO::PARAM_STR,
+        int $maxLength = 0,
+        mixed $driverOptions = null,
+    ): bool {
+    }
+
+    public function bindParam(
+        int|string $param,
+        mixed &$variable,
+        int $type = PDO::PARAM_STR,
+        int $maxLength = 0,
+        mixed $driverOptions = null,
+    ): bool {
+    }
+
+    public function bindValue(int|string $param, mixed $value, int $type = PDO::PARAM_STR): bool
+    {
+    }
+
+    public function closeCursor(): bool
+    {
+    }
+
+    /** @param array<mixed>|null $params */
+    public function execute(?array $params = null): bool
+    {
+    }
+
+    public function fetch(
+        int $mode = PDO::FETCH_DEFAULT,
+        int $cursorOrientation = PDO::FETCH_ORI_NEXT,
+        int $cursorOffset = 0,
+    ): mixed {
+    }
+
+    /** @return array<mixed> */
+    public function fetchAll(int $mode = PDO::FETCH_DEFAULT, mixed ...$args): array
+    {
+    }
+
+    public function fetchColumn(int $column = 0): mixed
+    {
+    }
+
+    public function getAttribute(int $attribute): mixed
+    {
+    }
+
+    public function rowCount(): int
+    {
+    }
+
+    public function setAttribute(int $attribute, mixed $value): bool
+    {
+    }
+
+    public function setFetchMode(int $mode, mixed ...$args): bool
+    {
+    }
+}
diff --git a/tests/e2e/Adapter/Base.php b/tests/e2e/Adapter/Base.php
index 4baeba35b0..2e428a2031 100644
--- a/tests/e2e/Adapter/Base.php
+++ b/tests/e2e/Adapter/Base.php
@@ -3,12 +3,14 @@
 namespace Tests\E2E\Adapter;
 
 use PHPUnit\Framework\TestCase;
+use Tests\E2E\Adapter\Scopes\AggregationTests;
 use Tests\E2E\Adapter\Scopes\AttributeTests;
 use Tests\E2E\Adapter\Scopes\CollectionTests;
-use Tests\E2E\Adapter\Scopes\CustomDocumentTypeTests;
 use Tests\E2E\Adapter\Scopes\DocumentTests;
 use Tests\E2E\Adapter\Scopes\GeneralTests;
 use Tests\E2E\Adapter\Scopes\IndexTests;
+use Tests\E2E\Adapter\Scopes\JoinComboTests;
+use Tests\E2E\Adapter\Scopes\JoinTests;
 use Tests\E2E\Adapter\Scopes\ObjectAttributeTests;
 use Tests\E2E\Adapter\Scopes\OperatorTests;
 use Tests\E2E\Adapter\Scopes\PermissionTests;
@@ -17,69 +19,69 @@
 use Tests\E2E\Adapter\Scopes\SpatialTests;
 use Tests\E2E\Adapter\Scopes\VectorTests;
 use Utopia\Database\Database;
+use Utopia\Database\Hook\Permissions;
+use Utopia\Database\Hook\Relationships;
 use Utopia\Database\Validator\Authorization;
 
 \ini_set('memory_limit', '2048M');
 
 abstract class Base extends TestCase
 {
+    use AggregationTests;
+    use AttributeTests;
     use CollectionTests;
-    use CustomDocumentTypeTests;
     use DocumentTests;
-    use AttributeTests;
+    use GeneralTests;
     use IndexTests;
+    use JoinComboTests;
+    use JoinTests;
+    use ObjectAttributeTests;
     use OperatorTests;
     use PermissionTests;
     use RelationshipTests;
-    use SpatialTests;
     use SchemalessTests;
-    use ObjectAttributeTests;
+    use SpatialTests;
     use VectorTests;
-    use GeneralTests;
 
     protected static string $namespace;
 
-    /**
-     * @var Authorization
-     */
     protected static ?Authorization $authorization = null;
 
-    /**
-     * @return Database
-     */
     abstract protected function getDatabase(): Database;
 
-    /**
-     * @param string $collection
-     * @param string $column
-     *
-     * @return bool
-     */
     abstract protected function deleteColumn(string $collection, string $column): bool;
 
-    /**
-     * @param string $collection
-     * @param string $index
-     *
-     * @return bool
-     */
     abstract protected function deleteIndex(string $collection, string $index): bool;
 
-    public function setUp(): void
+    protected function setUp(): void
     {
+        $this->testDatabase = 'utopiaTests_'.static::getTestToken();
+
         if (is_null(self::$authorization)) {
             self::$authorization = new Authorization();
         }
 
         self::$authorization->addRole('any');
+
+        $db = $this->getDatabase();
+        if ($db->getRelationshipHook() === null) {
+            $db->addHook(new Relationships($db));
+        }
+        if (! $db->getAdapter()->hasPermissionHook()) {
+            $db->addHook(new Permissions());
+        }
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
-        self::$authorization->setDefaultStatus(true);
+        self::$authorization?->setDefaultStatus(true);
 
     }
 
     protected string $testDatabase = 'utopiaTests';
 
+    protected static function getTestToken(): string
+    {
+        return getenv('TEST_TOKEN') ?: getenv('UNIQUE_TEST_TOKEN') ?: (string) getmypid();
+    }
 }
diff --git a/tests/e2e/Adapter/MariaDBTest.php b/tests/e2e/Adapter/MariaDBTest.php
index 923de242ed..5936bd1670 100644
--- a/tests/e2e/Adapter/MariaDBTest.php
+++ b/tests/e2e/Adapter/MariaDBTest.php
@@ -12,15 +12,14 @@
 class MariaDBTest extends Base
 {
     protected static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
-    /**
-     * @return Database
-     */
     public function getDatabase(bool $fresh = false): Database
     {
-        if (!is_null(self::$database) && !$fresh) {
+        if (! is_null(self::$database) && ! $fresh) {
             return self::$database;
         }
 
@@ -33,14 +32,15 @@ public function getDatabase(bool $fresh = false): Database
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(0);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new MariaDB($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setDatabase($this->testDatabase)
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -49,14 +49,16 @@ public function getDatabase(bool $fresh = false): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -64,9 +66,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/MemoryTest.php b/tests/e2e/Adapter/MemoryTest.php
index fcb36e1f60..106e6f614b 100644
--- a/tests/e2e/Adapter/MemoryTest.php
+++ b/tests/e2e/Adapter/MemoryTest.php
@@ -6,20 +6,24 @@
 use Utopia\Cache\Adapter\Redis as RedisAdapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\NotFound as NotFoundException;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
 
 /**
  * E2E tests for the in-memory adapter. Inherits the standard adapter scopes
  * from Base so it is exercised against the same scenarios as MariaDB/MySQL/
  * Postgres. Scope tests that depend on features Memory does not implement
- * (relationships, operators, vectors, spatial, fulltext, schemaless,
- * object attributes) self-skip via the adapter's getSupportFor* flags.
+ * (upserts, operators, vectors, spatial, fulltext, schemaless, object
+ * attributes) self-skip via Feature instanceof / Capability checks. Memory
+ * implements relationships.
  *
  * The test methods declared directly on this class are Memory-specific
  * regressions for behaviour that is not exercised — or not exercised in the
@@ -49,9 +53,10 @@ public function getDatabase(): Database
         $cache = new Cache(new RedisAdapter($redis));
 
         $database = new Database(new Memory(), $cache);
+        $authorization = self::$authorization ?? throw new \RuntimeException('Authorization not initialised');
         $database
-            ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setAuthorization($authorization)
+            ->setDatabase($this->testDatabase)
             ->setNamespace(static::$namespace = 'memory_' . uniqid());
 
         if ($database->exists()) {
@@ -87,17 +92,18 @@ private function freshDatabase(): Database
         $cache = new Cache(new RedisAdapter($redis));
 
         $database = new Database(new Memory(), $cache);
+        $authorization = self::$authorization ?? throw new \RuntimeException('Authorization not initialised');
         $database
-            ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setAuthorization($authorization)
+            ->setDatabase($this->testDatabase)
             ->setNamespace('memory_iso_' . uniqid());
         $database->create();
         return $database;
     }
 
     /**
-     * The inherited scope test does not gate on getSupportForUpserts(); skip
-     * here because Memory throws on upsert by design.
+     * The inherited scope test does not gate on instanceof Feature\Upserts;
+     * skip here because Memory throws on upsert by design.
      */
     public function testUpsertWithJSONFilters(): void
     {
@@ -106,7 +112,7 @@ public function testUpsertWithJSONFilters(): void
 
     /**
      * Operator scope tests that combine upserts with operators only gate on
-     * getSupportForOperators() — Memory doesn't implement upserts, so we
+     * Capability::Operators — Memory doesn't implement Feature\Upserts, so we
      * skip the upsert variants explicitly.
      */
     public function testBulkUpsertWithOperatorsCallbackReceivesFreshData(): void
@@ -129,32 +135,6 @@ public function testUpsertDocumentsWithAllOperators(): void
         $this->markTestSkipped('Memory adapter does not implement upserts.');
     }
 
-    /**
-     * Inherited test creates a self-relationship; Memory has no relationships.
-     */
-    public function testAttributeNamesWithDots(): void
-    {
-        $this->markTestSkipped('Memory adapter does not implement relationships.');
-    }
-
-    /**
-     * Inherited test asserts permission cascade through a relationship.
-     *
-     * @return array<mixed>
-     */
-    public function testCollectionPermissionsRelationships(): array
-    {
-        $this->markTestSkipped('Memory adapter does not implement relationships.');
-    }
-
-    /**
-     * Inherited test asserts cursor ordering across a relationship join.
-     */
-    public function testOrderAndCursorWithRelationshipQueries(): void
-    {
-        $this->markTestSkipped('Memory adapter does not implement relationships.');
-    }
-
     /**
      * Inherited test depends on PDO's automatic int->string coercion when an
      * INTEGER column is altered to VARCHAR. Memory keeps native PHP scalars,
@@ -189,16 +169,33 @@ public function testKeywords(): void
         $this->markTestSkipped('Memory has no reserved keywords.');
     }
 
+    /**
+     * SQL adapters round-trip values through column-typed encode/decode so a
+     * read-back $old equals the freshly-created $document when no field
+     * changed; Memory stores native PHP values verbatim, so encoded payloads
+     * (e.g. JSON-array attributes) come back as the encoded form rather than
+     * the decoded form the input document still holds. The strict ($value
+     * !== $oldValue) check then flips $shouldUpdate to true and trips the
+     * update-permission path even though the data is unchanged. The optimisation
+     * is safe to skip here since Memory's intended uses (tests, fixtures) do
+     * not rely on it.
+     */
+    public function testNoChangeUpdateDocumentWithoutPermission(): void
+    {
+        $this->markTestSkipped(
+            'Memory stores native PHP values rather than encoded column data, '
+            . 'so the no-change update optimisation does not apply.'
+        );
+    }
+
     /**
      * Memory does not implement upserts. Inherited scope tests that rely on
-     * upserts skip themselves via getSupportForUpserts().
+     * upserts skip themselves via instanceof Feature\Upserts.
      */
     public function testUpsertIsNotImplemented(): void
     {
-        $collection = new Document(['$id' => 'any']);
-
         $this->expectException(\Utopia\Database\Exception::class);
-        $this->freshDatabase()->getAdapter()->upsertDocuments($collection, '', []);
+        $this->freshDatabase()->upsertDocuments('any', []);
     }
 
     /**
@@ -209,20 +206,12 @@ public function testNestedTransactionRollbackOnlyDiscardsInner(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('nested', [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+        $database->createCollection(new Collection(id: 'nested', attributes: [
+            Attribute::string(key: 'name', size: 64, required: true),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $adapter = $database->getAdapter();
         $adapter->startTransaction();
@@ -255,20 +244,12 @@ public function testArrayAttributeRoundTrip(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('lists', [
-            new Document([
-                '$id' => 'tags',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => false,
-                'signed' => true,
-                'array' => true,
-                'filters' => [],
-            ]),
-        ], [], [
+        $database->createCollection(new Collection(id: 'lists', attributes: [
+            Attribute::string(key: 'tags', size: 64, array: true),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('lists', new Document([
             '$id' => 'l1',
@@ -300,7 +281,7 @@ public function testCreateUniqueIndexRejectsExistingDuplicates(): void
         );
 
         $this->expectException(DuplicateException::class);
-        $adapter->createIndex('emails', 'unique_addr', Database::INDEX_UNIQUE, ['addr'], [], []);
+        $adapter->createIndex('emails', Index::unique(key: 'unique_addr', attributes: ['addr']));
     }
 
     /**
@@ -311,26 +292,14 @@ public function testUniqueIndexAllowsMultipleNulls(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('optional', [
-            new Document([
-                '$id' => 'token',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => 'unique_token',
-                'type' => Database::INDEX_UNIQUE,
-                'attributes' => ['token'],
-            ]),
-        ], [
+        $database->createCollection(new Collection(id: 'optional', attributes: [
+            Attribute::string(key: 'token', size: 64),
+        ], indexes: [
+            Index::unique(key: 'unique_token', attributes: ['token']),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('optional', new Document([
             '$id' => 'a',
@@ -355,15 +324,19 @@ public function testUpdateAttributeAppliesMetadataAfterRename(): void
         $adapter = new Memory();
         $adapter->setNamespace('rename_' . \uniqid());
         $adapter->createCollection('renames', [], []);
-        $adapter->createAttribute('renames', 'old', Database::VAR_STRING, 64);
+        $adapter->createAttribute('renames', Attribute::string(key: 'old', size: 64));
 
-        $adapter->updateAttribute('renames', 'old', Database::VAR_STRING, 256, true, false, 'fresh');
+        $adapter->updateAttribute('renames', Attribute::string(key: 'old', size: 256), 'fresh');
 
         $store = (new \ReflectionClass($adapter))->getProperty('data')->getValue($adapter);
         $key = $adapter->getDatabase() . '.' . $adapter->getNamespace() . '_renames';
 
+        $this->assertIsArray($store);
+        $this->assertIsArray($store[$key]);
+        $this->assertIsArray($store[$key]['attributes']);
         $this->assertArrayHasKey('fresh', $store[$key]['attributes']);
         $this->assertArrayNotHasKey('old', $store[$key]['attributes']);
+        $this->assertIsArray($store[$key]['attributes']['fresh']);
         $this->assertEquals(256, $store[$key]['attributes']['fresh']['size']);
     }
 
@@ -376,14 +349,18 @@ public function testRenameAttributeUpdatesIndexReferences(): void
         $adapter = new Memory();
         $adapter->setNamespace('idxrn_' . \uniqid());
         $adapter->createCollection('indexed', [], []);
-        $adapter->createAttribute('indexed', 'name', Database::VAR_STRING, 64);
-        $adapter->createIndex('indexed', 'idx_name', Database::INDEX_KEY, ['name'], [], []);
+        $adapter->createAttribute('indexed', Attribute::string(key: 'name', size: 64));
+        $adapter->createIndex('indexed', Index::key(key: 'idx_name', attributes: ['name']));
 
         $adapter->renameAttribute('indexed', 'name', 'title');
 
         $store = (new \ReflectionClass($adapter))->getProperty('data')->getValue($adapter);
         $key = $adapter->getDatabase() . '.' . $adapter->getNamespace() . '_indexed';
 
+        $this->assertIsArray($store);
+        $this->assertIsArray($store[$key]);
+        $this->assertIsArray($store[$key]['indexes']);
+        $this->assertIsArray($store[$key]['indexes']['idx_name']);
         $this->assertEquals(['title'], $store[$key]['indexes']['idx_name']['attributes']);
     }
 
@@ -396,15 +373,19 @@ public function testDeleteAttributeRemovesFromIndex(): void
         $adapter = new Memory();
         $adapter->setNamespace('idxdrop_' . \uniqid());
         $adapter->createCollection('drops', [], []);
-        $adapter->createAttribute('drops', 'a', Database::VAR_STRING, 64);
-        $adapter->createAttribute('drops', 'b', Database::VAR_STRING, 64);
-        $adapter->createIndex('drops', 'idx_ab', Database::INDEX_KEY, ['a', 'b'], [], []);
+        $adapter->createAttribute('drops', Attribute::string(key: 'a', size: 64));
+        $adapter->createAttribute('drops', Attribute::string(key: 'b', size: 64));
+        $adapter->createIndex('drops', Index::key(key: 'idx_ab', attributes: ['a', 'b']));
 
         $adapter->deleteAttribute('drops', 'a');
 
         $store = (new \ReflectionClass($adapter))->getProperty('data')->getValue($adapter);
         $key = $adapter->getDatabase() . '.' . $adapter->getNamespace() . '_drops';
 
+        $this->assertIsArray($store);
+        $this->assertIsArray($store[$key]);
+        $this->assertIsArray($store[$key]['indexes']);
+        $this->assertIsArray($store[$key]['indexes']['idx_ab']);
         $this->assertEquals(['b'], $store[$key]['indexes']['idx_ab']['attributes']);
     }
 
@@ -416,27 +397,15 @@ public function testBatchUpdateEnforcesUniqueIndexes(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('handles', [
-            new Document([
-                '$id' => 'handle',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => 'unique_handle',
-                'type' => Database::INDEX_UNIQUE,
-                'attributes' => ['handle'],
-            ]),
-        ], [
+        $database->createCollection(new Collection(id: 'handles', attributes: [
+            Attribute::string(key: 'handle', size: 64, required: true),
+        ], indexes: [
+            Index::unique(key: 'unique_handle', attributes: ['handle']),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::update(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('handles', new Document([
             '$id' => 'h1',
@@ -473,27 +442,15 @@ public function testBatchUpdateRejectsSiblingCollision(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('siblings', [
-            new Document([
-                '$id' => 'handle',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => 'unique_handle',
-                'type' => Database::INDEX_UNIQUE,
-                'attributes' => ['handle'],
-            ]),
-        ], [
+        $database->createCollection(new Collection(id: 'siblings', attributes: [
+            Attribute::string(key: 'handle', size: 64, required: true),
+        ], indexes: [
+            Index::unique(key: 'unique_handle', attributes: ['handle']),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::update(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('siblings', new Document([
             '$id' => 's1',
@@ -528,20 +485,12 @@ public function testBulkDeleteRemovesPermissions(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('cleanup', [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+        $database->createCollection(new Collection(id: 'cleanup', attributes: [
+            Attribute::string(key: 'name', size: 64, required: true),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::delete(Role::any()),
-        ]);
+        ]));
 
         for ($i = 0; $i < 3; $i++) {
             $database->createDocument('cleanup', new Document([
@@ -557,6 +506,7 @@ public function testBulkDeleteRemovesPermissions(): void
         $permissions = (new \ReflectionClass($adapter))->getProperty('permissions')->getValue($adapter);
         $key = $database->getDatabase() . '.' . $database->getNamespace() . '_cleanup';
 
+        $this->assertIsArray($permissions);
         $this->assertEmpty($permissions[$key] ?? []);
     }
 
@@ -607,8 +557,8 @@ public function testSingleDocumentDateOperations(): void
     {
         $database = $this->getDatabase();
         $collection = 'single_date_operations_memory';
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false);
+        $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'string', size: 128));
 
         $database->setPreserveDates(true);
         $created = $database->createDocument($collection, new Document([
@@ -643,8 +593,8 @@ public function testSharedTablesUniqueIndexPerTenant(): void
         $adapter->setSharedTables(true);
         $adapter->setTenant(1);
         $adapter->createCollection('emails', [], []);
-        $adapter->createAttribute('emails', 'addr', Database::VAR_STRING, 128, true, false, true);
-        $adapter->createIndex('emails', 'unique_addr', Database::INDEX_UNIQUE, ['addr'], [], []);
+        $adapter->createAttribute('emails', Attribute::string(key: 'addr', size: 128, required: true));
+        $adapter->createIndex('emails', Index::unique(key: 'unique_addr', attributes: ['addr']));
 
         $collection = new Document(['$id' => 'emails']);
 
@@ -804,26 +754,14 @@ public function testUniqueIndexNormalizesBool(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('flags', [
-            new Document([
-                '$id' => 'active',
-                'type' => Database::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => 'unique_active',
-                'type' => Database::INDEX_UNIQUE,
-                'attributes' => ['active'],
-            ]),
-        ], [
+        $database->createCollection(new Collection(id: 'flags', attributes: [
+            Attribute::boolean(key: 'active', required: true),
+        ], indexes: [
+            Index::unique(key: 'unique_active', attributes: ['active']),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('flags', new Document([
             '$id' => 'first',
@@ -850,8 +788,8 @@ public function testUniqueIndexNormalizesNumericString(): void
         $adapter = new Memory();
         $adapter->setNamespace('numstr_' . \uniqid());
         $adapter->createCollection('codes', [], []);
-        $adapter->createAttribute('codes', 'code', Database::VAR_STRING, 16, true, false, true);
-        $adapter->createIndex('codes', 'unique_code', Database::INDEX_UNIQUE, ['code'], [], []);
+        $adapter->createAttribute('codes', Attribute::string(key: 'code', size: 16, required: true));
+        $adapter->createIndex('codes', Index::unique(key: 'unique_code', attributes: ['code']));
 
         $collection = new Document(['$id' => 'codes']);
 
@@ -879,35 +817,16 @@ public function testNegationOperatorsExcludeNullRows(): void
     {
         $database = $this->freshDatabase();
 
-        $database->createCollection('nullable', [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => false,
-            ]),
-            new Document([
-                '$id' => 'score',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false,
-            ]),
-            new Document([
-                '$id' => 'bio',
-                'type' => Database::VAR_STRING,
-                'size' => 1024,
-                'required' => false,
-            ]),
-        ], [
-            new Document([
-                '$id' => 'bio_ft',
-                'type' => Database::INDEX_FULLTEXT,
-                'attributes' => ['bio'],
-            ]),
-        ], [
+        $database->createCollection(new Collection(id: 'nullable', attributes: [
+            Attribute::string(key: 'name', size: 64),
+            Attribute::integer(key: 'score'),
+            Attribute::string(key: 'bio', size: 1024),
+        ], indexes: [
+            Index::fullText(key: 'bio_ft', attributes: ['bio']),
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('nullable', new Document([
             '$id' => 'with_value',
@@ -926,7 +845,7 @@ public function testNegationOperatorsExcludeNullRows(): void
         ]));
 
         $assertOnlyValueRow = function (string $operator, array $results) {
-            $ids = \array_map(fn (Document $d) => $d->getId(), $results);
+            $ids = \array_map(fn (mixed $d): string => $d instanceof Document ? $d->getId() : '', $results);
             $this->assertSame(['with_value'], $ids, $operator . ' should exclude null-valued rows');
         };
 
diff --git a/tests/e2e/Adapter/MirrorTest.php b/tests/e2e/Adapter/MirrorTest.php
index de73d7be86..395434e77e 100644
--- a/tests/e2e/Adapter/MirrorTest.php
+++ b/tests/e2e/Adapter/MirrorTest.php
@@ -6,6 +6,8 @@
 use Utopia\Cache\Adapter\Redis as RedisAdapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
@@ -22,9 +24,13 @@
 class MirrorTest extends Base
 {
     protected static ?Mirror $database = null;
+
     protected static ?PDO $destinationPdo = null;
+
     protected static ?PDO $sourcePdo = null;
+
     protected static Database $source;
+
     protected static Database $destination;
 
     protected static string $namespace;
@@ -35,7 +41,7 @@ class MirrorTest extends Base
      */
     protected function getDatabase(bool $fresh = false): Mirror
     {
-        if (!is_null(self::$database) && !$fresh) {
+        if (! is_null(self::$database) && ! $fresh) {
             return self::$database;
         }
 
@@ -48,8 +54,8 @@ protected function getDatabase(bool $fresh = false): Mirror
 
         $redis = new Redis();
         $redis->connect('redis');
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(5);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         self::$sourcePdo = $pdo;
         self::$source = new Database(new MariaDB($pdo), $cache);
@@ -63,43 +69,51 @@ protected function getDatabase(bool $fresh = false): Mirror
 
         $mirrorRedis = new Redis();
         $mirrorRedis->connect('redis-mirror');
-        $mirrorRedis->flushAll();
-        $mirrorCache = new Cache(new RedisAdapter($mirrorRedis));
+        $mirrorRedis->select(5);
+        $mirrorCache = new Cache((new RedisAdapter($mirrorRedis))->setMaxRetries(3));
 
         self::$destinationPdo = $mirrorPdo;
         self::$destination = new Database(new MariaDB($mirrorPdo), $mirrorCache);
 
         $database = new Mirror(self::$source, self::$destination);
 
+        $token = static::getTestToken();
         $schemas = [
-            'utopiaTests',
-            'schema1',
-            'schema2',
-            'sharedTables',
-            'sharedTablesTenantPerDocument'
+            $this->testDatabase,
+            'schema1_'.$token,
+            'schema2_'.$token,
+            'sharedTables_'.$token,
+            'sharedTablesTenantPerDocument_'.$token,
         ];
 
         /**
          * Handle cases where the source and destination databases are not in sync because of previous tests
          */
+        assert(self::$authorization !== null);
         foreach ($schemas as $schema) {
             if ($database->getSource()->exists($schema)) {
                 $database->getSource()->setAuthorization(self::$authorization);
                 $database->getSource()->setDatabase($schema)->delete();
             }
-            if ($database->getDestination()->exists($schema)) {
-                $database->getDestination()->setAuthorization(self::$authorization);
-                $database->getDestination()->setDatabase($schema)->delete();
+            $destination = $database->getDestination();
+            if ($destination !== null && $destination->exists($schema)) {
+                $destination->setAuthorization(self::$authorization);
+                $destination->setDatabase($schema)->delete();
             }
         }
 
         $database
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setAuthorization(self::$authorization)
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         $database->create();
 
+        $destination = $database->getDestination();
+        if ($destination === null || ! $destination->exists($this->testDatabase, Database::METADATA)) {
+            throw new Exception('Mirror destination is missing _metadata after create');
+        }
+
         return self::$database = $database;
     }
 
@@ -107,11 +121,10 @@ protected function getDatabase(bool $fresh = false): Mirror
      * @throws Exception
      * @throws \RedisException
      */
-    public function testGetMirrorSource(): void
+    public function test_get_mirror_source(): void
     {
         $database = $this->getDatabase();
         $source = $database->getSource();
-        $this->assertInstanceOf(Database::class, $source);
         $this->assertEquals(self::$source, $source);
     }
 
@@ -119,7 +132,7 @@ public function testGetMirrorSource(): void
      * @throws Exception
      * @throws \RedisException
      */
-    public function testGetMirrorDestination(): void
+    public function test_get_mirror_destination(): void
     {
         $database = $this->getDatabase();
         $destination = $database->getDestination();
@@ -133,15 +146,17 @@ public function testGetMirrorDestination(): void
      * @throws Exception
      * @throws \RedisException
      */
-    public function testCreateMirroredCollection(): void
+    public function test_create_mirrored_collection(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testCreateMirroredCollection');
+        $database->createCollection(new Collection(id: 'testCreateMirroredCollection'));
 
         // Assert collection exists in both databases
         $this->assertFalse($database->getSource()->getCollection('testCreateMirroredCollection')->isEmpty());
-        $this->assertFalse($database->getDestination()->getCollection('testCreateMirroredCollection')->isEmpty());
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
+        $this->assertFalse($destination->getCollection('testCreateMirroredCollection')->isEmpty());
     }
 
     /**
@@ -151,13 +166,13 @@ public function testCreateMirroredCollection(): void
      * @throws Conflict
      * @throws Exception
      */
-    public function testUpdateMirroredCollection(): void
+    public function test_update_mirrored_collection(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testUpdateMirroredCollection', permissions: [
+        $database->createCollection(new Collection(id: 'testUpdateMirroredCollection', permissions: [
             Permission::read(Role::any()),
-        ]);
+        ]));
 
         $collection = $database->getCollection('testUpdateMirroredCollection');
 
@@ -166,7 +181,7 @@ public function testUpdateMirroredCollection(): void
             [
                 Permission::read(Role::users()),
             ],
-            $collection->getAttribute('documentSecurity')
+            (bool) $collection->getAttribute('documentSecurity')
         );
 
         // Asset both databases have updated the collection
@@ -175,23 +190,27 @@ public function testUpdateMirroredCollection(): void
             $database->getSource()->getCollection('testUpdateMirroredCollection')->getPermissions()
         );
 
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
         $this->assertEquals(
             [Permission::read(Role::users())],
-            $database->getDestination()->getCollection('testUpdateMirroredCollection')->getPermissions()
+            $destination->getCollection('testUpdateMirroredCollection')->getPermissions()
         );
     }
 
-    public function testDeleteMirroredCollection(): void
+    public function test_delete_mirrored_collection(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testDeleteMirroredCollection');
+        $database->createCollection(new Collection(id: 'testDeleteMirroredCollection'));
 
         $database->deleteCollection('testDeleteMirroredCollection');
 
         // Assert collection is deleted in both databases
         $this->assertTrue($database->getSource()->getCollection('testDeleteMirroredCollection')->isEmpty());
-        $this->assertTrue($database->getDestination()->getCollection('testDeleteMirroredCollection')->isEmpty());
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
+        $this->assertTrue($destination->getCollection('testDeleteMirroredCollection')->isEmpty());
     }
 
     /**
@@ -202,25 +221,20 @@ public function testDeleteMirroredCollection(): void
      * @throws Structure
      * @throws Exception
      */
-    public function testCreateMirroredDocument(): void
+    public function test_create_mirrored_document(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testCreateMirroredDocument', attributes: [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'required' => true,
-                'size' => Database::LENGTH_KEY,
-            ]),
+        $database->createCollection(new Collection(id: 'testCreateMirroredDocument', attributes: [
+            Attribute::string(key: 'name', required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
         $document = $database->createDocument('testCreateMirroredDocument', new Document([
             'name' => 'Jake',
-            '$permissions' => []
+            '$permissions' => [],
         ]));
 
         // Assert document is created in both databases
@@ -229,9 +243,11 @@ public function testCreateMirroredDocument(): void
             $database->getSource()->getDocument('testCreateMirroredDocument', $document->getId())
         );
 
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
         $this->assertEquals(
             $document,
-            $database->getDestination()->getDocument('testCreateMirroredDocument', $document->getId())
+            $destination->getDocument('testCreateMirroredDocument', $document->getId())
         );
     }
 
@@ -244,26 +260,21 @@ public function testCreateMirroredDocument(): void
      * @throws Structure
      * @throws Exception
      */
-    public function testUpdateMirroredDocument(): void
+    public function test_update_mirrored_document(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testUpdateMirroredDocument', attributes: [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'required' => true,
-                'size' => Database::LENGTH_KEY,
-            ]),
+        $database->createCollection(new Collection(id: 'testUpdateMirroredDocument', attributes: [
+            Attribute::string(key: 'name', required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::update(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
         $document = $database->createDocument('testUpdateMirroredDocument', new Document([
             'name' => 'Jake',
-            '$permissions' => []
+            '$permissions' => [],
         ]));
 
         $document = $database->updateDocument(
@@ -278,39 +289,38 @@ public function testUpdateMirroredDocument(): void
             $database->getSource()->getDocument('testUpdateMirroredDocument', $document->getId())
         );
 
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
         $this->assertEquals(
             $document,
-            $database->getDestination()->getDocument('testUpdateMirroredDocument', $document->getId())
+            $destination->getDocument('testUpdateMirroredDocument', $document->getId())
         );
     }
 
-    public function testDeleteMirroredDocument(): void
+    public function test_delete_mirrored_document(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('testDeleteMirroredDocument', attributes: [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'required' => true,
-                'size' => Database::LENGTH_KEY,
-            ]),
+        $database->createCollection(new Collection(id: 'testDeleteMirroredDocument', attributes: [
+            Attribute::string(key: 'name', required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::delete(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
         $document = $database->createDocument('testDeleteMirroredDocument', new Document([
             'name' => 'Jake',
-            '$permissions' => []
+            '$permissions' => [],
         ]));
 
         $database->deleteDocument('testDeleteMirroredDocument', $document->getId());
 
         // Assert document is deleted in both databases
         $this->assertTrue($database->getSource()->getDocument('testDeleteMirroredDocument', $document->getId())->isEmpty());
-        $this->assertTrue($database->getDestination()->getDocument('testDeleteMirroredDocument', $document->getId())->isEmpty());
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
+        $this->assertTrue($destination->getDocument('testDeleteMirroredDocument', $document->getId())->isEmpty());
     }
 
     public function testCreateDocumentsSkipDuplicatesBackfillsDestination(): void
@@ -318,17 +328,12 @@ public function testCreateDocumentsSkipDuplicatesBackfillsDestination(): void
         $database = $this->getDatabase();
         $collection = 'mirrorSkipDup';
 
-        $database->createCollection($collection, attributes: [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'required' => true,
-                'size' => Database::LENGTH_KEY,
-            ]),
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'name', required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
         // Seed the SOURCE only (bypass the mirror) with the row we want to
         // skipDuplicates over later. Destination intentionally does NOT have it —
@@ -343,12 +348,15 @@ public function testCreateDocumentsSkipDuplicatesBackfillsDestination(): void
             ],
         ]));
 
+        $destination = $database->getDestination();
+        $this->assertNotNull($destination);
+
         $this->assertSame(
             'Original',
             $database->getSource()->getDocument($collection, 'dup')->getAttribute('name')
         );
         $this->assertTrue(
-            $database->getDestination()->getDocument($collection, 'dup')->isEmpty()
+            $destination->getDocument($collection, 'dup')->isEmpty()
         );
 
         $database->skipDuplicates(fn () => $database->createDocuments($collection, [
@@ -385,25 +393,27 @@ public function testCreateDocumentsSkipDuplicatesBackfillsDestination(): void
         // destination is still catching up on rows that already exist on source.
         $this->assertSame(
             'WouldBe',
-            $database->getDestination()->getDocument($collection, 'dup')->getAttribute('name'),
+            $destination->getDocument($collection, 'dup')->getAttribute('name'),
             'Source-skipped doc must still insert on destination when absent there'
         );
         $this->assertSame(
             'Fresh',
-            $database->getDestination()->getDocument($collection, 'fresh')->getAttribute('name')
+            $destination->getDocument($collection, 'fresh')->getAttribute('name')
         );
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . self::$source->getDatabase() . "`.`" . self::$source->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.self::$source->getDatabase().'`.`'.self::$source->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$sourcePdo !== null);
         self::$sourcePdo->exec($sql);
 
-        $sqlTable = "`" . self::$destination->getDatabase() . "`.`" . self::$destination->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.self::$destination->getDatabase().'`.`'.self::$destination->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$destinationPdo !== null);
         self::$destinationPdo->exec($sql);
 
         return true;
@@ -411,14 +421,16 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . self::$source->getDatabase() . "`.`" . self::$source->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.self::$source->getDatabase().'`.`'.self::$source->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$sourcePdo !== null);
         self::$sourcePdo->exec($sql);
 
-        $sqlTable = "`" . self::$destination->getDatabase() . "`.`" . self::$destination->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.self::$destination->getDatabase().'`.`'.self::$destination->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$destinationPdo !== null);
         self::$destinationPdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/MongoDBTest.php b/tests/e2e/Adapter/MongoDBTest.php
index 1c7eb9237e..4779a1c568 100644
--- a/tests/e2e/Adapter/MongoDBTest.php
+++ b/tests/e2e/Adapter/MongoDBTest.php
@@ -13,34 +13,32 @@
 class MongoDBTest extends Base
 {
     public static ?Database $database = null;
+
     protected static string $namespace;
 
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "mongodb";
+        return 'mongodb';
     }
 
     /**
-     * @return Database
      * @throws Exception
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(4);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
-        $schema = 'utopiaTests'; // same as $this->testDatabase
+        $schema = $this->testDatabase;
         $client = new Client(
             $schema,
             'mongo',
@@ -52,10 +50,11 @@ public function getDatabase(): Database
 
         $database = new Database(new Mongo($client), $cache);
         $database->getAdapter()->setSupportForAttributes(true);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
             ->setDatabase($schema)
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -69,33 +68,33 @@ public function getDatabase(): Database
     /**
      * @throws Exception
      */
-    public function testCreateExistsDelete(): void
+    public function test_create_exists_delete(): void
     {
         // Mongo creates databases on the fly, so exists would always pass. So we override this test to remove the exists check.
-        $this->assertNotNull($this->getDatabase()->create());
+        $this->assertSame(true, $this->getDatabase()->create());
         $this->assertEquals(true, $this->getDatabase()->delete($this->testDatabase));
         $this->assertEquals(true, $this->getDatabase()->create());
         $this->assertEquals($this->getDatabase(), $this->getDatabase()->setDatabase($this->testDatabase));
     }
 
-    public function testRenameAttribute(): void
+    public function test_rename_attribute(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testRenameAttributeExisting(): void
+    public function test_rename_attribute_existing(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testUpdateAttributeStructure(): void
+    public function test_update_attribute_structure(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testKeywords(): void
+    public function test_keywords(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
     protected function deleteColumn(string $collection, string $column): bool
diff --git a/tests/e2e/Adapter/MySQLTest.php b/tests/e2e/Adapter/MySQLTest.php
index 8e92bb216b..4e45fa7405 100644
--- a/tests/e2e/Adapter/MySQLTest.php
+++ b/tests/e2e/Adapter/MySQLTest.php
@@ -15,18 +15,19 @@
 class MySQLTest extends Base
 {
     public static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     /**
-     * @return Database
      * @throws Duplicate
      * @throws Exception
      * @throws Limit
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
@@ -39,14 +40,15 @@ public function getDatabase(): Database
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(1);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new MySQL($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setDatabase($this->testDatabase)
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -55,14 +57,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -70,9 +74,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/PoolTest.php b/tests/e2e/Adapter/PoolTest.php
index 2164ba391c..4ca891844b 100644
--- a/tests/e2e/Adapter/PoolTest.php
+++ b/tests/e2e/Adapter/PoolTest.php
@@ -9,6 +9,8 @@
 use Utopia\Database\Adapter;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Pool;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
@@ -28,24 +30,24 @@ class PoolTest extends Base
      * @var UtopiaPool<MySQL>
      */
     protected static UtopiaPool $pool;
+
     protected static string $namespace;
 
     /**
-     * @return Database
      * @throws Exception
      * @throws Duplicate
      * @throws Limit
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(6);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $pool = new UtopiaPool(new Stack(), 'mysql', 10, function () {
             $dbHost = 'mysql';
@@ -62,11 +64,11 @@ public function getDatabase(): Database
         }, timeout: 0.0);
 
         $database = new Database(new Pool($pool), $cache);
-
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setDatabase($this->testDatabase)
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -81,7 +83,7 @@ public function getDatabase(): Database
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
         self::$pool->use(function (Adapter $adapter) use ($sql) {
@@ -90,6 +92,7 @@ protected function deleteColumn(string $collection, string $column): bool
             $property = $class->getProperty('pdo');
             $property->setAccessible(true);
             $pdo = $property->getValue($adapter);
+            assert($pdo instanceof PDO);
             $pdo->exec($sql);
         });
 
@@ -98,7 +101,7 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
         self::$pool->use(function (Adapter $adapter) use ($sql) {
@@ -107,6 +110,7 @@ protected function deleteIndex(string $collection, string $index): bool
             $property = $class->getProperty('pdo');
             $property->setAccessible(true);
             $pdo = $property->getValue($adapter);
+            assert($pdo instanceof PDO);
             $pdo->exec($sql);
         });
 
@@ -116,8 +120,7 @@ protected function deleteIndex(string $collection, string $index): bool
     /**
      * Execute raw SQL via the pool using reflection to access the adapter's PDO.
      *
-     * @param string $sql
-     * @param array<string, mixed> $binds
+     * @param  array<string, mixed>  $binds
      */
     private function execRawSQL(string $sql, array $binds = []): void
     {
@@ -126,6 +129,7 @@ private function execRawSQL(string $sql, array $binds = []): void
             $property = $class->getProperty('pdo');
             $property->setAccessible(true);
             $pdo = $property->getValue($adapter);
+            assert($pdo instanceof PDO);
             $stmt = $pdo->prepare($sql);
             foreach ($binds as $key => $value) {
                 $stmt->bindValue($key, $value);
@@ -139,13 +143,13 @@ private function execRawSQL(string $sql, array $binds = []): void
      * don't block document recreation. The createDocument method should
      * clean up orphaned perms and retry.
      */
-    public function testOrphanedPermissionsRecovery(): void
+    public function test_orphaned_permissions_recovery(): void
     {
         $database = $this->getDatabase();
         $collection = 'orphanedPermsRecovery';
 
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'title', Database::VAR_STRING, 128, true);
+        $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'title', size: 128, required: true));
 
         // Step 1: Create a document with permissions
         $doc = $database->createDocument($collection, new Document([
diff --git a/tests/e2e/Adapter/PostgresTest.php b/tests/e2e/Adapter/PostgresTest.php
index 14afc6db74..1ad6f8f147 100644
--- a/tests/e2e/Adapter/PostgresTest.php
+++ b/tests/e2e/Adapter/PostgresTest.php
@@ -6,17 +6,20 @@
 use Utopia\Cache\Adapter\Redis as RedisAdapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\PDO;
-use Utopia\Database\Query;
 
 class PostgresTest extends Base
 {
     public static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     /**
@@ -24,7 +27,7 @@ class PostgresTest extends Base
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
@@ -36,14 +39,15 @@ public function getDatabase(): Database
         $pdo = new PDO("pgsql:host={$dbHost};port={$dbPort};", $dbUser, $dbPass, Postgres::getPDOAttributes());
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(2);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new Postgres($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setDatabase($this->testDatabase)
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -52,14 +56,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = '"' . $this->getDatabase()->getDatabase(). '"."' . $this->getDatabase()->getNamespace() . '_' . $collection . '"';
+        $sqlTable = '"'.$this->getDatabase()->getDatabase().'"."'.$this->getDatabase()->getNamespace().'_'.$collection.'"';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN \"{$column}\"";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -67,129 +73,45 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $key = "\"".$this->getDatabase()->getNamespace()."_".$this->getDatabase()->getTenant()."_{$collection}_{$index}\"";
+        $key = '"'.$this->getDatabase()->getNamespace().'_'.$this->getDatabase()->getTenant()."_{$collection}_{$index}\"";
 
-        $sql = "DROP INDEX \"".$this->getDatabase()->getDatabase()."\".{$key}";
+        $sql = 'DROP INDEX "'.$this->getDatabase()->getDatabase()."\".{$key}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
     }
 
-    /**
-     * Reading must be answerable from the row alone. The permissions table holds the same fact,
-     * but reaching it needs a join, and a join has to be resolved before anything can be ordered,
-     * which costs a full read of the collection whenever the ordering could have come from an
-     * index instead.
-     */
-    public function testReadDoesNotTouchThePermissionsTable(): void
+    public function testCreateCollectionWithMongoSequenceShapedId(): void
     {
         $database = $this->getDatabase();
+        $collection = 'database_507f1f77bcf86cd799439012_collection_507f1f77bcf86cd799439013';
 
-        // no collection level read, so the permission is enforced per document
-        $database->createCollection('permsPlan', permissions: [
-            Permission::create(Role::any()),
-        ], documentSecurity: true);
-
-        $database->createAttribute('permsPlan', 'title', Database::VAR_STRING, 64, true);
-
-        foreach (['visible' => Role::any(), 'hidden' => Role::user('nobody')] as $title => $role) {
-            $database->createDocument('permsPlan', new Document([
-                '$permissions' => [Permission::read($role)],
-                'title' => $title,
-            ]));
-        }
-
-        $table = $database->getNamespace() . '_permsPlan_perms';
-
-        $scans = function () use ($table): int {
-            self::$pdo->query('SELECT pg_stat_force_next_flush()');
-            self::$pdo->query('SELECT pg_stat_clear_snapshot()');
-
-            $statement = self::$pdo->prepare('SELECT COALESCE(SUM(seq_scan + COALESCE(idx_scan, 0)), 0) FROM pg_stat_user_tables WHERE relname = :table');
-            $statement->execute([':table' => $table]);
-
-            return (int)$statement->fetchColumn();
-        };
-
-        $before = $scans();
-
-        $results = $database->find('permsPlan');
-
-        $this->assertCount(1, $results, 'Only the readable document may come back');
-        $this->assertSame('visible', $results[0]->getAttribute('title'));
-
-        $this->assertSame(
-            $before,
-            $scans(),
-            'A read must be satisfied from the row, without reaching the permissions table'
+        $this->assertGreaterThan(
+            Postgres::MAX_IDENTIFIER_NAME,
+            \strlen($database->getNamespace().'_'.$collection)
         );
 
-        $database->deleteCollection('permsPlan');
-    }
-
-    /**
-     * A vector search must order by distance alone, because a vector index can answer exactly
-     * one sort key. Adding a second one does not merely make the index look expensive, it makes
-     * it unusable, and the collection is read in full instead.
-     *
-     * Sequential scans are priced out of the session so that the planner falls back to one only
-     * when the index genuinely cannot answer the ordering. That separates a hard block from a
-     * costing preference, and keeps the assertion independent of how many rows are present.
-     */
-    public function testVectorSearchUsesTheIndex(): void
-    {
-        $database = $this->getDatabase();
-
-        $database->createCollection('vectorPlan', permissions: [
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'name', size: 128, required: true),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ], documentSecurity: false);
-
-        $database->createAttribute('vectorPlan', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createIndex('vectorPlan', 'idx_cosine', Database::INDEX_HNSW_COSINE, ['embedding']);
-
-        for ($i = 0; $i < 50; $i++) {
-            $database->createDocument('vectorPlan', new Document([
-                '$permissions' => [Permission::read(Role::any())],
-                'embedding' => [$i / 50, 1 - ($i / 50), 0.0],
-            ]));
-        }
-
-        $index = $database->getNamespace() . '_' . $database->getTenant() . '_vectorPlan_idx_cosine';
-
-        $scans = function () use ($index): int {
-            self::$pdo->query('SELECT pg_stat_force_next_flush()');
-            self::$pdo->query('SELECT pg_stat_clear_snapshot()');
-
-            $statement = self::$pdo->prepare('SELECT COALESCE(SUM(idx_scan), 0) FROM pg_stat_user_indexes WHERE indexrelname = :index');
-            $statement->execute([':index' => $index]);
-
-            return (int)$statement->fetchColumn();
-        };
-
-        $before = $scans();
-
-        self::$pdo->exec('SET enable_seqscan = off');
-
-        try {
-            $results = $database->find('vectorPlan', [
-                Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-                Query::limit(10),
-            ]);
-        } finally {
-            self::$pdo->exec('RESET enable_seqscan');
-        }
-
-        $this->assertCount(10, $results);
-        $this->assertEqualsWithDelta(0.0, $results[0]->getAttribute(Database::VECTOR_DISTANCE), 0.001);
-
-        $this->assertGreaterThan(
-            $before,
-            $scans(),
-            'A vector search must be answerable from the vector index, not by reading the collection'
-        );
-
-        $database->deleteCollection('vectorPlan');
+            Permission::update(Role::any()),
+        ]));
+
+        $document = $database->createDocument($collection, new Document([
+            '$id' => 'vector-doc',
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+            'name' => 'embeddings',
+        ]));
+
+        $this->assertSame('vector-doc', $document->getId());
+        $this->assertSame('embeddings', $database->getDocument($collection, 'vector-doc')->getAttribute('name'));
+        $this->assertTrue($database->exists($database->getDatabase(), $collection));
+        $this->assertTrue($database->deleteCollection($collection));
     }
 }
diff --git a/tests/e2e/Adapter/RedisTest.php b/tests/e2e/Adapter/RedisTest.php
index 23d779db0f..9a4f07e1b7 100644
--- a/tests/e2e/Adapter/RedisTest.php
+++ b/tests/e2e/Adapter/RedisTest.php
@@ -8,13 +8,20 @@
 use Utopia\Database\Adapter\Redis as RedisAdapter;
 use Utopia\Database\Database;
 
+/**
+ * Paratest's `--functional` mode invokes `setUpBeforeClass`/`tearDownAfterClass`
+ * between every test method, not just at suite boundaries, while inherited
+ * fixture statics (`$moviesFixtureInit`, `$documentsFixtureInit`, etc.) stay
+ * set across methods within the same worker process. Scrubbing the namespace
+ * or recreating the `Database` between tests would leave the cached fixture
+ * metadata pointing at collections that no longer exist. The CI Redis
+ * container is ephemeral, so leaking keys to process exit is safe.
+ */
 class RedisTest extends Base
 {
     public static ?Database $database = null;
     public static ?Redis $redisClient = null;
     public static string $redisNamespace = '';
-    /** @var array<int, string> Adapter-keyspace SCAN patterns the run owns, scrubbed in tearDownAfterClass. */
-    protected static array $keyPatterns = [];
 
     public static function getAdapterName(): string
     {
@@ -42,7 +49,7 @@ public function getDatabase(): Database
             self::$authorization = new \Utopia\Database\Validator\Authorization();
         }
 
-        $host = \getenv('REDIS_HOST') ?: 'redis-mirror';
+        $host = \getenv('REDIS_HOST') ?: 'redis';
         $port = (int) (\getenv('REDIS_PORT') ?: 6379);
 
         $client = new Redis();
@@ -61,18 +68,11 @@ public function getDatabase(): Database
         $database = new Database($adapter, $cache);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setNamespace(self::$redisNamespace);
 
         $this->configureDatabase($database);
 
-        // Track every adapter-keyspace pattern this run owns so
-        // tearDownAfterClass can scrub without a global FLUSH. The
-        // configureDatabase() call above may have mutated the namespace
-        // (shared-tables uses ''), so capture the post-configure namespace
-        // too.
-        self::$keyPatterns = self::buildKeyPatterns(self::$redisNamespace, $database->getNamespace(), $database->getDatabase());
-
         if ($database->exists()) {
             $database->delete();
         }
@@ -82,27 +82,6 @@ public function getDatabase(): Database
         return self::$database = $database;
     }
 
-    /**
-     * Build SCAN MATCH patterns covering the adapter keyspace for every
-     * namespace this test class actually wrote to. The two-namespace form
-     * (initial + post-configure) covers the shared-tables case where
-     * setNamespace('') is applied before create().
-     *
-     * @return array<int, string>
-     */
-    protected static function buildKeyPatterns(string $initialNamespace, string $effectiveNamespace, string $database): array
-    {
-        $patterns = [];
-        $namespaces = \array_unique([$initialNamespace, $effectiveNamespace]);
-        foreach ($namespaces as $namespace) {
-            // Adapter writes: `KEY_PREFIX:{namespace}:{database}:*`. Empty
-            // namespace produces a literal double-colon, which is a valid
-            // SCAN pattern.
-            $patterns[] = RedisAdapter::KEY_PREFIX . ':' . $namespace . ':' . $database . ':*';
-        }
-        return \array_values(\array_unique($patterns));
-    }
-
     protected function deleteColumn(string $collection, string $column): bool
     {
         // Redis keeps no out-of-band schema; raw column drops do not apply.
@@ -137,36 +116,4 @@ public function testUpdateAttributeSize(): void
         );
     }
 
-    public static function tearDownAfterClass(): void
-    {
-        try {
-            if (self::$keyPatterns !== [] && self::$redisClient instanceof Redis) {
-                self::scrubKeys(self::$redisClient, self::$keyPatterns);
-            }
-        } finally {
-            self::$database = null;
-            self::$redisClient = null;
-            self::$redisNamespace = '';
-            self::$keyPatterns = [];
-            parent::tearDownAfterClass();
-        }
-    }
-
-    /**
-     * @param array<int, string> $patterns
-     */
-    private static function scrubKeys(Redis $client, array $patterns): void
-    {
-        foreach ($patterns as $pattern) {
-            $iterator = null;
-            while (($keys = $client->scan($iterator, $pattern, 500)) !== false) {
-                if (\is_array($keys) && \count($keys) > 0) {
-                    $client->del($keys);
-                }
-                if ($iterator === 0) {
-                    break;
-                }
-            }
-        }
-    }
 }
diff --git a/tests/e2e/Adapter/SQLiteTest.php b/tests/e2e/Adapter/SQLiteTest.php
index 6a6945e502..1c83605f05 100644
--- a/tests/e2e/Adapter/SQLiteTest.php
+++ b/tests/e2e/Adapter/SQLiteTest.php
@@ -12,41 +12,41 @@
 class SQLiteTest extends Base
 {
     public static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
-    /**
-     * @return Database
-     */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
-        $db = __DIR__."/database.sql";
+        $db = __DIR__.'/database_'.static::getTestToken().'.sql';
 
         if (file_exists($db)) {
             unlink($db);
         }
 
         $dsn = $db;
-        //$dsn = 'memory'; // Overwrite for fast tests
-        $pdo = new PDO("sqlite:" . $dsn, null, null, SQLite::getPDOAttributes());
+        // $dsn = 'memory'; // Overwrite for fast tests
+        $pdo = new PDO('sqlite:'.$dsn, null, null, SQLite::getPDOAttributes());
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(3);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $adapter = new SQLite($pdo);
         $adapter->setEmulateMySQL(true);
 
         $database = new Database($adapter, $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setDatabase($this->testDatabase)
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -55,14 +55,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -70,9 +72,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $index = "`".$this->getDatabase()->getNamespace()."_".$this->getDatabase()->getTenant()."_{$collection}_{$index}`";
+        $index = '`'.$this->getDatabase()->getNamespace().'_'.$this->getDatabase()->getTenant()."_{$collection}_{$index}`";
         $sql = "DROP INDEX {$index}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/Schemaless/MongoDBTest.php b/tests/e2e/Adapter/Schemaless/MongoDBTest.php
index 04ebd79f98..0db142660b 100644
--- a/tests/e2e/Adapter/Schemaless/MongoDBTest.php
+++ b/tests/e2e/Adapter/Schemaless/MongoDBTest.php
@@ -14,34 +14,32 @@
 class MongoDBTest extends Base
 {
     public static ?Database $database = null;
+
     protected static string $namespace;
 
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "mongodb";
+        return 'mongodb';
     }
 
     /**
-     * @return Database
      * @throws Exception
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(12);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
-        $schema = 'utopiaTests'; // same as $this->testDatabase
+        $schema = $this->testDatabase;
         $client = new Client(
             $schema,
             'mongo',
@@ -53,16 +51,16 @@ public function getDatabase(): Database
 
         $database = new Database(new Mongo($client), $cache);
         $database->getAdapter()->setSupportForAttributes(false);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
             ->setDatabase($schema)
-            ->setNamespace(static::$namespace = 'myapp_' . uniqid());
+            ->setNamespace(static::$namespace = 'myapp_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
         }
 
-
         $database->create();
 
         return self::$database = $database;
@@ -71,33 +69,33 @@ public function getDatabase(): Database
     /**
      * @throws Exception
      */
-    public function testCreateExistsDelete(): void
+    public function test_create_exists_delete(): void
     {
         // Mongo creates databases on the fly, so exists would always pass. So we override this test to remove the exists check.
-        $this->assertNotNull(static::getDatabase()->create());
+        $this->assertSame(true, static::getDatabase()->create());
         $this->assertEquals(true, $this->getDatabase()->delete($this->testDatabase));
         $this->assertEquals(true, $this->getDatabase()->create());
         $this->assertEquals($this->getDatabase(), $this->getDatabase()->setDatabase($this->testDatabase));
     }
 
-    public function testRenameAttribute(): void
+    public function test_rename_attribute(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testRenameAttributeExisting(): void
+    public function test_rename_attribute_existing(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testUpdateAttributeStructure(): void
+    public function test_update_attribute_structure(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testKeywords(): void
+    public function test_keywords(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
     protected function deleteColumn(string $collection, string $column): bool
diff --git a/tests/e2e/Adapter/Scopes/AggregationTests.php b/tests/e2e/Adapter/Scopes/AggregationTests.php
new file mode 100644
index 0000000000..6393c5dda4
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/AggregationTests.php
@@ -0,0 +1,1626 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+
+trait AggregationTests
+{
+    /** @var array<string, bool> */
+    private static array $createdProductCollections = [];
+    private static string $aggWorkerSuffix = '';
+
+    private function getAggSuffix(): string
+    {
+        if (self::$aggWorkerSuffix === '') {
+            self::$aggWorkerSuffix = '_' . substr(uniqid(), -6);
+        }
+
+        return self::$aggWorkerSuffix;
+    }
+
+    private function numericAttribute(Document $document, string $key): float
+    {
+        $value = $document->getAttribute($key);
+        $this->assertIsNumeric($value);
+
+        return (float) $value;
+    }
+
+    private function intAttribute(Document $document, string $key): int
+    {
+        $value = $document->getAttribute($key);
+        $this->assertIsNumeric($value);
+
+        return (int) $value;
+    }
+
+    private function createProducts(Database $database, string $collection = 'agg_products'): void
+    {
+        if (isset(self::$createdProductCollections[$collection])) {
+            return;
+        }
+
+        if ($database->exists($database->getDatabase(), $collection)) {
+            self::$createdProductCollections[$collection] = true;
+            return;
+        }
+
+        $database->createCollection(new Collection(id: $collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 100, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'price', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'stock', required: true));
+        $database->createAttribute($collection, Attribute::double(key: 'rating', default: 0.0));
+
+        $products = [
+            ['$id' => 'laptop', 'name' => 'Laptop', 'category' => 'electronics', 'price' => 1200, 'stock' => 50, 'rating' => 4.5],
+            ['$id' => 'phone', 'name' => 'Phone', 'category' => 'electronics', 'price' => 800, 'stock' => 100, 'rating' => 4.2],
+            ['$id' => 'tablet', 'name' => 'Tablet', 'category' => 'electronics', 'price' => 500, 'stock' => 75, 'rating' => 3.8],
+            ['$id' => 'shirt', 'name' => 'Shirt', 'category' => 'clothing', 'price' => 30, 'stock' => 200, 'rating' => 4.0],
+            ['$id' => 'pants', 'name' => 'Pants', 'category' => 'clothing', 'price' => 50, 'stock' => 150, 'rating' => 3.5],
+            ['$id' => 'jacket', 'name' => 'Jacket', 'category' => 'clothing', 'price' => 120, 'stock' => 80, 'rating' => 4.7],
+            ['$id' => 'novel', 'name' => 'Novel', 'category' => 'books', 'price' => 15, 'stock' => 300, 'rating' => 4.8],
+            ['$id' => 'textbook', 'name' => 'Textbook', 'category' => 'books', 'price' => 60, 'stock' => 40, 'rating' => 3.2],
+            ['$id' => 'comic', 'name' => 'Comic', 'category' => 'books', 'price' => 10, 'stock' => 500, 'rating' => 4.1],
+        ];
+
+        foreach ($products as $product) {
+            $database->createDocument($collection, new Document(array_merge($product, [
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ])));
+        }
+    }
+
+    private function createOrders(Database $database, string $collection = 'agg_orders'): void
+    {
+        if ($database->exists($database->getDatabase(), $collection)) {
+            $database->deleteCollection($collection);
+        }
+
+        $database->createCollection(new Collection(id: $collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($collection, Attribute::string(key: 'product_uid', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'customer_uid', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'quantity', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'total', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'status', size: 20, required: true));
+
+        $orders = [
+            ['$id' => 'ord1', 'product_uid' => 'laptop', 'customer_uid' => 'alice', 'quantity' => 1, 'total' => 1200, 'status' => 'completed'],
+            ['$id' => 'ord2', 'product_uid' => 'phone', 'customer_uid' => 'alice', 'quantity' => 2, 'total' => 1600, 'status' => 'completed'],
+            ['$id' => 'ord3', 'product_uid' => 'shirt', 'customer_uid' => 'alice', 'quantity' => 3, 'total' => 90, 'status' => 'pending'],
+            ['$id' => 'ord4', 'product_uid' => 'laptop', 'customer_uid' => 'bob', 'quantity' => 1, 'total' => 1200, 'status' => 'completed'],
+            ['$id' => 'ord5', 'product_uid' => 'novel', 'customer_uid' => 'bob', 'quantity' => 5, 'total' => 75, 'status' => 'completed'],
+            ['$id' => 'ord6', 'product_uid' => 'tablet', 'customer_uid' => 'charlie', 'quantity' => 1, 'total' => 500, 'status' => 'cancelled'],
+            ['$id' => 'ord7', 'product_uid' => 'jacket', 'customer_uid' => 'charlie', 'quantity' => 2, 'total' => 240, 'status' => 'completed'],
+            ['$id' => 'ord8', 'product_uid' => 'phone', 'customer_uid' => 'diana', 'quantity' => 1, 'total' => 800, 'status' => 'pending'],
+            ['$id' => 'ord9', 'product_uid' => 'pants', 'customer_uid' => 'diana', 'quantity' => 4, 'total' => 200, 'status' => 'completed'],
+            ['$id' => 'ord10', 'product_uid' => 'comic', 'customer_uid' => 'diana', 'quantity' => 10, 'total' => 100, 'status' => 'completed'],
+        ];
+
+        foreach ($orders as $order) {
+            $database->createDocument($collection, new Document(array_merge($order, [
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ])));
+        }
+    }
+
+    private function createCustomers(Database $database, string $collection = 'agg_customers'): void
+    {
+        if ($database->exists($database->getDatabase(), $collection)) {
+            $database->deleteCollection($collection);
+        }
+
+        $database->createCollection(new Collection(id: $collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 100, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'email', size: 200, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'country', size: 50, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'tier', size: 20, required: true));
+
+        $customers = [
+            ['$id' => 'alice', 'name' => 'Alice', 'email' => 'alice@test.com', 'country' => 'US', 'tier' => 'premium'],
+            ['$id' => 'bob', 'name' => 'Bob', 'email' => 'bob@test.com', 'country' => 'US', 'tier' => 'basic'],
+            ['$id' => 'charlie', 'name' => 'Charlie', 'email' => 'charlie@test.com', 'country' => 'UK', 'tier' => 'vip'],
+            ['$id' => 'diana', 'name' => 'Diana', 'email' => 'diana@test.com', 'country' => 'UK', 'tier' => 'premium'],
+            ['$id' => 'eve', 'name' => 'Eve', 'email' => 'eve@test.com', 'country' => 'DE', 'tier' => 'basic'],
+        ];
+
+        foreach ($customers as $customer) {
+            $database->createDocument($collection, new Document(array_merge($customer, [
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ])));
+        }
+    }
+
+    private function createReviews(Database $database, string $collection = 'agg_reviews'): void
+    {
+        if ($database->exists($database->getDatabase(), $collection)) {
+            $database->deleteCollection($collection);
+        }
+
+        $database->createCollection(new Collection(id: $collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($collection, Attribute::string(key: 'product_uid', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'customer_uid', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'score', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'comment', size: 500, default: ''));
+
+        $reviews = [
+            ['product_uid' => 'laptop', 'customer_uid' => 'alice', 'score' => 5, 'comment' => 'Excellent'],
+            ['product_uid' => 'laptop', 'customer_uid' => 'bob', 'score' => 4, 'comment' => 'Good'],
+            ['product_uid' => 'laptop', 'customer_uid' => 'charlie', 'score' => 3, 'comment' => 'Average'],
+            ['product_uid' => 'phone', 'customer_uid' => 'alice', 'score' => 4, 'comment' => 'Nice'],
+            ['product_uid' => 'phone', 'customer_uid' => 'diana', 'score' => 5, 'comment' => 'Great'],
+            ['product_uid' => 'shirt', 'customer_uid' => 'bob', 'score' => 2, 'comment' => 'Poor fit'],
+            ['product_uid' => 'shirt', 'customer_uid' => 'charlie', 'score' => 4, 'comment' => 'Nice fabric'],
+            ['product_uid' => 'novel', 'customer_uid' => 'diana', 'score' => 5, 'comment' => 'Loved it'],
+            ['product_uid' => 'novel', 'customer_uid' => 'alice', 'score' => 5, 'comment' => 'Must read'],
+            ['product_uid' => 'novel', 'customer_uid' => 'eve', 'score' => 4, 'comment' => 'Good story'],
+            ['product_uid' => 'jacket', 'customer_uid' => 'charlie', 'score' => 5, 'comment' => 'Perfect'],
+            ['product_uid' => 'textbook', 'customer_uid' => 'eve', 'score' => 1, 'comment' => 'Boring'],
+        ];
+
+        foreach ($reviews as $review) {
+            $database->createDocument($collection, new Document(array_merge($review, [
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ])));
+        }
+    }
+
+    /**
+     * @param  array<string>  $collections
+     */
+    private function cleanupAggCollections(Database $database, array $collections): void
+    {
+        foreach ($collections as $col) {
+            if ($database->exists($database->getDatabase(), $col)) {
+                $database->deleteCollection($col);
+            }
+        }
+    }
+
+    public function testCountAll(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_all');
+        $results = $database->find('cnt_all', [Query::count('*', 'total')]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(9, $results[0]->getAttribute('total'));
+        $database->deleteCollection('cnt_all');
+    }
+
+    public function testCountWithAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_alias');
+        $results = $database->find('cnt_alias', [Query::count('*', 'num_products')]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(9, $results[0]->getAttribute('num_products'));
+        $database->deleteCollection('cnt_alias');
+    }
+
+    public function testCountWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_filter');
+
+        $results = $database->find('cnt_filter', [
+            Query::equal('category', ['electronics']),
+            Query::count('*', 'total'),
+        ]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('total'));
+
+        $results = $database->find('cnt_filter', [
+            Query::equal('category', ['clothing']),
+            Query::count('*', 'total'),
+        ]);
+        $this->assertEquals(3, $results[0]->getAttribute('total'));
+
+        $results = $database->find('cnt_filter', [
+            Query::greaterThan('price', 100),
+            Query::count('*', 'total'),
+        ]);
+        $this->assertEquals(4, $results[0]->getAttribute('total'));
+
+        $database->deleteCollection('cnt_filter');
+    }
+
+    public function testCountEmptyCollection(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'cnt_empty';
+        if ($database->exists($database->getDatabase(), $col)) {
+            $database->deleteCollection($col);
+        }
+        $database->createCollection(new Collection(id: $col, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($col, Attribute::integer(key: 'value', required: true));
+
+        $results = $database->find($col, [Query::count('*', 'total')]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(0, $results[0]->getAttribute('total'));
+
+        $database->deleteCollection($col);
+    }
+
+    public function testCountWithMultipleFilters(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_multi');
+
+        $results = $database->find('cnt_multi', [
+            Query::equal('category', ['electronics']),
+            Query::greaterThan('price', 600),
+            Query::count('*', 'total'),
+        ]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(2, $results[0]->getAttribute('total'));
+
+        $database->deleteCollection('cnt_multi');
+    }
+
+    public function testCountDistinct(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_distinct');
+        $results = $database->find('cnt_distinct', [Query::countDistinct('category', 'unique_cats')]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('unique_cats'));
+        $database->deleteCollection('cnt_distinct');
+    }
+
+    public function testCountDistinctWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'cnt_dist_f');
+        $results = $database->find('cnt_dist_f', [
+            Query::greaterThan('price', 50),
+            Query::countDistinct('category', 'unique_cats'),
+        ]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('unique_cats'));
+        $database->deleteCollection('cnt_dist_f');
+    }
+
+    public function testSumAll(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'sum_all');
+        $results = $database->find('sum_all', [Query::sum('price', 'total_price')]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(2785, $results[0]->getAttribute('total_price'));
+        $database->deleteCollection('sum_all');
+    }
+
+    public function testSumWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'sum_filt');
+        $results = $database->find('sum_filt', [
+            Query::equal('category', ['electronics']),
+            Query::sum('price', 'total'),
+        ]);
+        $this->assertEquals(2500, $results[0]->getAttribute('total'));
+        $database->deleteCollection('sum_filt');
+    }
+
+    public function testSumEmptyResult(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'sum_empty');
+        $results = $database->find('sum_empty', [
+            Query::equal('category', ['nonexistent']),
+            Query::sum('price', 'total'),
+        ]);
+        $this->assertCount(1, $results);
+        $this->assertNull($results[0]->getAttribute('total'));
+        $database->deleteCollection('sum_empty');
+    }
+
+    public function testSumOfStock(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'sum_stock');
+        $results = $database->find('sum_stock', [Query::sum('stock', 'total_stock')]);
+        $this->assertEquals(1495, $results[0]->getAttribute('total_stock'));
+        $database->deleteCollection('sum_stock');
+    }
+
+    public function testAvgAll(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'avg_all');
+        $results = $database->find('avg_all', [Query::avg('price', 'avg_price')]);
+        $this->assertCount(1, $results);
+        $this->assertEqualsWithDelta(309.44, $this->numericAttribute($results[0], 'avg_price'), 1.0);
+        $database->deleteCollection('avg_all');
+    }
+
+    public function testAvgWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'avg_filt');
+        $results = $database->find('avg_filt', [
+            Query::equal('category', ['electronics']),
+            Query::avg('price', 'avg_price'),
+        ]);
+        $this->assertEqualsWithDelta(833.33, $this->numericAttribute($results[0], 'avg_price'), 1.0);
+        $database->deleteCollection('avg_filt');
+    }
+
+    public function testAvgOfRating(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'avg_rating');
+        $results = $database->find('avg_rating', [Query::avg('rating', 'avg_rating')]);
+        $this->assertEqualsWithDelta(4.09, $this->numericAttribute($results[0], 'avg_rating'), 0.1);
+        $database->deleteCollection('avg_rating');
+    }
+
+    public function testMinAll(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'min_all');
+        $results = $database->find('min_all', [Query::min('price', 'min_price')]);
+        $this->assertEquals(10, $results[0]->getAttribute('min_price'));
+        $database->deleteCollection('min_all');
+    }
+
+    public function testMinWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'min_filt');
+        $results = $database->find('min_filt', [
+            Query::equal('category', ['electronics']),
+            Query::min('price', 'cheapest'),
+        ]);
+        $this->assertEquals(500, $results[0]->getAttribute('cheapest'));
+        $database->deleteCollection('min_filt');
+    }
+
+    public function testMaxAll(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'max_all');
+        $results = $database->find('max_all', [Query::max('price', 'max_price')]);
+        $this->assertEquals(1200, $results[0]->getAttribute('max_price'));
+        $database->deleteCollection('max_all');
+    }
+
+    public function testMaxWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'max_filt');
+        $results = $database->find('max_filt', [
+            Query::equal('category', ['books']),
+            Query::max('price', 'expensive'),
+        ]);
+        $this->assertEquals(60, $results[0]->getAttribute('expensive'));
+        $database->deleteCollection('max_filt');
+    }
+
+    public function testMinMaxTogether(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'minmax');
+        $results = $database->find('minmax', [
+            Query::min('price', 'cheapest'),
+            Query::max('price', 'priciest'),
+        ]);
+        $this->assertCount(1, $results);
+        $this->assertEquals(10, $results[0]->getAttribute('cheapest'));
+        $this->assertEquals(1200, $results[0]->getAttribute('priciest'));
+        $database->deleteCollection('minmax');
+    }
+
+    public function testMultipleAggregationsTogether(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'multi_agg');
+        $results = $database->find('multi_agg', [
+            Query::count('*', 'total_count'),
+            Query::sum('price', 'total_price'),
+            Query::avg('price', 'avg_price'),
+            Query::min('price', 'min_price'),
+            Query::max('price', 'max_price'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(9, $results[0]->getAttribute('total_count'));
+        $this->assertEquals(2785, $results[0]->getAttribute('total_price'));
+        $this->assertEqualsWithDelta(309.44, $this->numericAttribute($results[0], 'avg_price'), 1.0);
+        $this->assertEquals(10, $results[0]->getAttribute('min_price'));
+        $this->assertEquals(1200, $results[0]->getAttribute('max_price'));
+        $database->deleteCollection('multi_agg');
+    }
+
+    public function testMultipleAggregationsWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'multi_agg_f');
+        $results = $database->find('multi_agg_f', [
+            Query::equal('category', ['clothing']),
+            Query::count('*', 'cnt'),
+            Query::sum('price', 'total'),
+            Query::avg('stock', 'avg_stock'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('cnt'));
+        $this->assertEquals(200, $results[0]->getAttribute('total'));
+        $this->assertEqualsWithDelta(143.33, $this->numericAttribute($results[0], 'avg_stock'), 1.0);
+        $database->deleteCollection('multi_agg_f');
+    }
+
+    public function testGroupBySingleColumn(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_single');
+        $results = $database->find('grp_single', [
+            Query::count('*', 'cnt'),
+            Query::groupBy(['category']),
+        ]);
+
+        $this->assertCount(3, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $mapped[$category] = $doc;
+        }
+        $this->assertEquals(3, $mapped['electronics']->getAttribute('cnt'));
+        $this->assertEquals(3, $mapped['clothing']->getAttribute('cnt'));
+        $this->assertEquals(3, $mapped['books']->getAttribute('cnt'));
+        $database->deleteCollection('grp_single');
+    }
+
+    public function testGroupByWithSum(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_sum');
+        $results = $database->find('grp_sum', [
+            Query::sum('price', 'total_price'),
+            Query::groupBy(['category']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $mapped[$category] = $doc;
+        }
+        $this->assertEquals(2500, $mapped['electronics']->getAttribute('total_price'));
+        $this->assertEquals(200, $mapped['clothing']->getAttribute('total_price'));
+        $this->assertEquals(85, $mapped['books']->getAttribute('total_price'));
+        $database->deleteCollection('grp_sum');
+    }
+
+    public function testGroupByWithAvg(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_avg');
+        $results = $database->find('grp_avg', [
+            Query::avg('price', 'avg_price'),
+            Query::groupBy(['category']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $value = $doc->getAttribute('avg_price');
+            $this->assertIsNumeric($value);
+            $mapped[$category] = (float) $value;
+        }
+        $this->assertEqualsWithDelta(833.33, $mapped['electronics'], 1.0);
+        $this->assertEqualsWithDelta(66.67, $mapped['clothing'], 1.0);
+        $this->assertEqualsWithDelta(28.33, $mapped['books'], 1.0);
+        $database->deleteCollection('grp_avg');
+    }
+
+    public function testGroupByWithMinMax(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_minmax');
+        $results = $database->find('grp_minmax', [
+            Query::min('price', 'cheapest'),
+            Query::max('price', 'priciest'),
+            Query::groupBy(['category']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $mapped[$category] = $doc;
+        }
+        $this->assertEquals(500, $mapped['electronics']->getAttribute('cheapest'));
+        $this->assertEquals(1200, $mapped['electronics']->getAttribute('priciest'));
+        $this->assertEquals(30, $mapped['clothing']->getAttribute('cheapest'));
+        $this->assertEquals(120, $mapped['clothing']->getAttribute('priciest'));
+        $this->assertEquals(10, $mapped['books']->getAttribute('cheapest'));
+        $this->assertEquals(60, $mapped['books']->getAttribute('priciest'));
+        $database->deleteCollection('grp_minmax');
+    }
+
+    public function testGroupByWithMultipleAggregations(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_multi');
+        $results = $database->find('grp_multi', [
+            Query::count('*', 'cnt'),
+            Query::sum('price', 'total'),
+            Query::avg('rating', 'avg_rating'),
+            Query::min('stock', 'min_stock'),
+            Query::max('stock', 'max_stock'),
+            Query::groupBy(['category']),
+        ]);
+
+        $this->assertCount(3, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $mapped[$category] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['electronics']->getAttribute('cnt'));
+        $this->assertEquals(2500, $mapped['electronics']->getAttribute('total'));
+        $this->assertEquals(50, $mapped['electronics']->getAttribute('min_stock'));
+        $this->assertEquals(100, $mapped['electronics']->getAttribute('max_stock'));
+
+        $this->assertEquals(3, $mapped['books']->getAttribute('cnt'));
+        $this->assertEquals(85, $mapped['books']->getAttribute('total'));
+        $this->assertEquals(40, $mapped['books']->getAttribute('min_stock'));
+        $this->assertEquals(500, $mapped['books']->getAttribute('max_stock'));
+
+        $database->deleteCollection('grp_multi');
+    }
+
+    public function testGroupByWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'grp_filt');
+        $results = $database->find('grp_filt', [
+            Query::greaterThan('price', 50),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['category']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $category = $doc->getAttribute('category');
+            $this->assertIsString($category);
+            $mapped[$category] = $doc;
+        }
+        $this->assertEquals(3, $mapped['electronics']->getAttribute('cnt'));
+        $this->assertEquals(1, $mapped['clothing']->getAttribute('cnt'));
+        $this->assertEquals(1, $mapped['books']->getAttribute('cnt'));
+        $database->deleteCollection('grp_filt');
+    }
+
+    public function testGroupByOrdersStatus(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'grp_status');
+        $results = $database->find('grp_status', [
+            Query::count('*', 'cnt'),
+            Query::sum('total', 'revenue'),
+            Query::groupBy(['status']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $status = $doc->getAttribute('status');
+            $this->assertIsString($status);
+            $mapped[$status] = $doc;
+        }
+        $this->assertEquals(7, $mapped['completed']->getAttribute('cnt'));
+        $this->assertEquals(2, $mapped['pending']->getAttribute('cnt'));
+        $this->assertEquals(1, $mapped['cancelled']->getAttribute('cnt'));
+        $database->deleteCollection('grp_status');
+    }
+
+    public function testGroupByCustomerOrders(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'grp_cust');
+        $results = $database->find('grp_cust', [
+            Query::count('*', 'order_count'),
+            Query::sum('total', 'total_spent'),
+            Query::avg('total', 'avg_order'),
+            Query::groupBy(['customer_uid']),
+        ]);
+
+        $this->assertCount(4, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $customer_uid = $doc->getAttribute('customer_uid');
+            $this->assertIsString($customer_uid);
+            $mapped[$customer_uid] = $doc;
+        }
+        $this->assertEquals(3, $mapped['alice']->getAttribute('order_count'));
+        $this->assertEquals(2890, $mapped['alice']->getAttribute('total_spent'));
+        $this->assertEquals(2, $mapped['bob']->getAttribute('order_count'));
+        $this->assertEquals(1275, $mapped['bob']->getAttribute('total_spent'));
+        $database->deleteCollection('grp_cust');
+    }
+
+    public function testHavingGreaterThan(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'having_gt');
+        $results = $database->find('having_gt', [
+            Query::sum('price', 'total_price'),
+            Query::groupBy(['category']),
+            Query::having([Query::greaterThan('total_price', 100)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $categories = array_map(fn ($d) => $d->getAttribute('category'), $results);
+        $this->assertContains('electronics', $categories);
+        $this->assertContains('clothing', $categories);
+        $this->assertNotContains('books', $categories);
+        $database->deleteCollection('having_gt');
+    }
+
+    public function testHavingLessThan(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'having_lt');
+        $results = $database->find('having_lt', [
+            Query::count('*', 'cnt'),
+            Query::sum('price', 'total'),
+            Query::groupBy(['category']),
+            Query::having([Query::lessThan('total', 500)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $categories = array_map(fn ($d) => $d->getAttribute('category'), $results);
+        $this->assertContains('clothing', $categories);
+        $this->assertContains('books', $categories);
+        $database->deleteCollection('having_lt');
+    }
+
+    public function testHavingWithCount(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createReviews($database, 'having_cnt');
+        $results = $database->find('having_cnt', [
+            Query::count('*', 'review_count'),
+            Query::groupBy(['product_uid']),
+            Query::having([Query::greaterThanEqual('review_count', 3)]),
+        ]);
+
+        $productIds = array_map(fn ($d) => $d->getAttribute('product_uid'), $results);
+        $this->assertContains('laptop', $productIds);
+        $this->assertContains('novel', $productIds);
+        $this->assertNotContains('jacket', $productIds);
+        $database->deleteCollection('having_cnt');
+    }
+
+    public function testInnerJoinBasic(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'ij_orders');
+        $this->createCustomers($database, 'ij_customers');
+
+        $results = $database->find('ij_orders', [
+            Query::join('ij_customers', 'customer_uid', '$id'),
+            Query::count('*', 'total'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(10, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, ['ij_orders', 'ij_customers']);
+    }
+
+    public function testInnerJoinWithGroupBy(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'ij_grp_o');
+        $this->createCustomers($database, 'ij_grp_c');
+
+        $results = $database->find('ij_grp_o', [
+            Query::join('ij_grp_c', 'customer_uid', '$id'),
+            Query::sum('total', 'total_spent'),
+            Query::count('*', 'order_count'),
+            Query::groupBy(['customer_uid']),
+        ]);
+
+        $this->assertCount(4, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $customer_uid = $doc->getAttribute('customer_uid');
+            $this->assertIsString($customer_uid);
+            $mapped[$customer_uid] = $doc;
+        }
+        $this->assertEquals(2890, $mapped['alice']->getAttribute('total_spent'));
+        $this->assertEquals(3, $mapped['alice']->getAttribute('order_count'));
+        $this->assertEquals(1275, $mapped['bob']->getAttribute('total_spent'));
+        $this->assertEquals(2, $mapped['bob']->getAttribute('order_count'));
+
+        $this->cleanupAggCollections($database, ['ij_grp_o', 'ij_grp_c']);
+    }
+
+    public function testInnerJoinWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'ij_filt_o');
+        $this->createCustomers($database, 'ij_filt_c');
+
+        $results = $database->find('ij_filt_o', [
+            Query::join('ij_filt_c', 'customer_uid', '$id'),
+            Query::equal('status', ['completed']),
+            Query::sum('total', 'revenue'),
+            Query::groupBy(['customer_uid']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $customer_uid = $doc->getAttribute('customer_uid');
+            $this->assertIsString($customer_uid);
+            $mapped[$customer_uid] = $doc;
+        }
+        $this->assertEquals(2800, $mapped['alice']->getAttribute('revenue'));
+        $this->assertEquals(1275, $mapped['bob']->getAttribute('revenue'));
+        $this->assertEquals(240, $mapped['charlie']->getAttribute('revenue'));
+        $this->assertEquals(300, $mapped['diana']->getAttribute('revenue'));
+
+        $this->cleanupAggCollections($database, ['ij_filt_o', 'ij_filt_c']);
+    }
+
+    public function testInnerJoinWithHaving(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createOrders($database, 'ij_hav_o');
+        $this->createCustomers($database, 'ij_hav_c');
+
+        $results = $database->find('ij_hav_o', [
+            Query::join('ij_hav_c', 'customer_uid', '$id'),
+            Query::sum('total', 'total_spent'),
+            Query::groupBy(['customer_uid']),
+            Query::having([Query::greaterThan('total_spent', 1000)]),
+        ]);
+
+        $this->assertCount(3, $results);
+        $customerIds = array_map(fn ($d) => $d->getAttribute('customer_uid'), $results);
+        $this->assertContains('alice', $customerIds);
+        $this->assertContains('bob', $customerIds);
+        $this->assertContains('diana', $customerIds);
+
+        $this->cleanupAggCollections($database, ['ij_hav_o', 'ij_hav_c']);
+    }
+
+    public function testInnerJoinProductReviewStats(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'ij_prs_p');
+        $this->createReviews($database, 'ij_prs_r');
+
+        $results = $database->find('ij_prs_p', [
+            Query::join('ij_prs_r', '$id', 'product_uid'),
+            Query::count('*', 'review_count'),
+            Query::avg('score', 'avg_score'),
+            Query::groupBy(['name']),
+        ]);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['Laptop']->getAttribute('review_count'));
+        $this->assertEqualsWithDelta(4.0, $this->numericAttribute($mapped['Laptop'], 'avg_score'), 0.1);
+        $this->assertEquals(3, $mapped['Novel']->getAttribute('review_count'));
+        $this->assertEqualsWithDelta(4.67, $this->numericAttribute($mapped['Novel'], 'avg_score'), 0.1);
+
+        $this->cleanupAggCollections($database, ['ij_prs_p', 'ij_prs_r']);
+    }
+
+    public function testLeftJoinBasic(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'lj_basic_p');
+        $this->createReviews($database, 'lj_basic_r');
+
+        $results = $database->find('lj_basic_p', [
+            Query::leftJoin('lj_basic_r', '$id', 'product_uid'),
+            Query::count('*', 'review_count'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(9, $results);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['Laptop']->getAttribute('review_count'));
+        $this->assertEquals(2, $mapped['Phone']->getAttribute('review_count'));
+        $this->assertEquals(1, $mapped['Tablet']->getAttribute('review_count'));
+        $this->assertEquals(1, $mapped['Comic']->getAttribute('review_count'));
+
+        $this->cleanupAggCollections($database, ['lj_basic_p', 'lj_basic_r']);
+    }
+
+    public function testLeftJoinWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createProducts($database, 'lj_filt_p');
+        $this->createOrders($database, 'lj_filt_o');
+
+        $results = $database->find('lj_filt_p', [
+            Query::leftJoin('lj_filt_o', '$id', 'product_uid'),
+            Query::equal('category', ['electronics']),
+            Query::count('*', 'order_count'),
+            Query::sum('quantity', 'total_qty'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(3, $results);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+        $this->assertEquals(2, $mapped['Laptop']->getAttribute('order_count'));
+        $this->assertEquals(2, $mapped['Phone']->getAttribute('order_count'));
+
+        $this->cleanupAggCollections($database, ['lj_filt_p', 'lj_filt_o']);
+    }
+
+    public function testLeftJoinCustomerOrderSummary(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->createCustomers($database, 'lj_cos_c');
+        $this->createOrders($database, 'lj_cos_o');
+
+        $results = $database->find('lj_cos_c', [
+            Query::leftJoin('lj_cos_o', '$id', 'customer_uid'),
+            Query::count('*', 'order_count'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(5, $results);
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['Alice']->getAttribute('order_count'));
+        $this->assertEquals(2, $mapped['Bob']->getAttribute('order_count'));
+        $this->assertEquals(2, $mapped['Charlie']->getAttribute('order_count'));
+        $this->assertEquals(3, $mapped['Diana']->getAttribute('order_count'));
+        $this->assertEquals(1, $mapped['Eve']->getAttribute('order_count'));
+
+        $this->cleanupAggCollections($database, ['lj_cos_c', 'lj_cos_o']);
+    }
+
+    public function testJoinAggregationWithPermissionsGrouped(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $cols = ['jp_apg_o', 'jp_apg_c'];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: 'jp_apg_c', permissions: [Permission::create(Role::any()), Permission::read(Role::any()), Permission::read(Role::user('viewer'))]));
+        $database->createAttribute('jp_apg_c', Attribute::string(key: 'name', size: 100, required: true));
+        $database->createCollection(new Collection(id: 'jp_apg_o', permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute('jp_apg_o', Attribute::string(key: 'customer_uid', required: true));
+        $database->createAttribute('jp_apg_o', Attribute::integer(key: 'amount', required: true));
+
+        foreach (['u1', 'u2'] as $uid) {
+            $database->createDocument('jp_apg_c', new Document([
+                '$id' => $uid, 'name' => 'User ' . $uid,
+                '$permissions' => [Permission::read(Role::any()), Permission::read(Role::user('viewer'))],
+            ]));
+        }
+
+        $database->createDocument('jp_apg_o', new Document([
+            'customer_uid' => 'u1', 'amount' => 100,
+            '$permissions' => [Permission::read(Role::user('viewer'))],
+        ]));
+        $database->createDocument('jp_apg_o', new Document([
+            'customer_uid' => 'u1', 'amount' => 200,
+            '$permissions' => [Permission::read(Role::user('viewer'))],
+        ]));
+        $database->createDocument('jp_apg_o', new Document([
+            'customer_uid' => 'u2', 'amount' => 500,
+            '$permissions' => [Permission::read(Role::user('admin'))],
+        ]));
+        $database->createDocument('jp_apg_o', new Document([
+            'customer_uid' => 'u2', 'amount' => 50,
+            '$permissions' => [Permission::read(Role::user('viewer'))],
+        ]));
+
+        $database->getAuthorization()->cleanRoles();
+        $database->getAuthorization()->addRole(Role::user('viewer')->toString());
+
+        $results = $database->find('jp_apg_o', [
+            Query::join('jp_apg_c', 'customer_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['customer_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $customer_uid = $doc->getAttribute('customer_uid');
+            $this->assertIsString($customer_uid);
+            $mapped[$customer_uid] = $doc;
+        }
+        $this->assertEquals(300, $mapped['u1']->getAttribute('total'));
+        $this->assertEquals(2, $mapped['u1']->getAttribute('cnt'));
+        $this->assertEquals(50, $mapped['u2']->getAttribute('total'));
+        $this->assertEquals(1, $mapped['u2']->getAttribute('cnt'));
+
+        $database->getAuthorization()->cleanRoles();
+        $database->getAuthorization()->addRole('any');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinPermissionFiltered(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $cols = ['jp_ljpf_p', 'jp_ljpf_r'];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: 'jp_ljpf_p', permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute('jp_ljpf_p', Attribute::string(key: 'name', size: 100, required: true));
+        $database->createCollection(new Collection(id: 'jp_ljpf_r', permissions: [Permission::create(Role::any()), Permission::read(Role::any()), Permission::read(Role::user('tester'))]));
+        $database->createAttribute('jp_ljpf_r', Attribute::string(key: 'product_uid', required: true));
+        $database->createAttribute('jp_ljpf_r', Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument('jp_ljpf_p', new Document([
+            '$id' => 'visible', 'name' => 'Visible Product',
+            '$permissions' => [Permission::read(Role::user('tester'))],
+        ]));
+        $database->createDocument('jp_ljpf_p', new Document([
+            '$id' => 'hidden', 'name' => 'Hidden Product',
+            '$permissions' => [Permission::read(Role::user('admin'))],
+        ]));
+
+        foreach (['visible', 'visible', 'hidden'] as $pid) {
+            $database->createDocument('jp_ljpf_r', new Document([
+                'product_uid' => $pid, 'score' => 5,
+                '$permissions' => [Permission::read(Role::any()), Permission::read(Role::user('tester'))],
+            ]));
+        }
+
+        $database->getAuthorization()->cleanRoles();
+        $database->getAuthorization()->addRole(Role::user('tester')->toString());
+
+        $results = $database->find('jp_ljpf_p', [
+            Query::leftJoin('jp_ljpf_r', '$id', 'product_uid'),
+            Query::count('*', 'review_count'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('Visible Product', $results[0]->getAttribute('name'));
+        $this->assertEquals(2, $results[0]->getAttribute('review_count'));
+
+        $database->getAuthorization()->cleanRoles();
+        $database->getAuthorization()->addRole('any');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    /**
+     * @return array<string, array{string, string, string, string, array<Query>, int|float}>
+     */
+    public static function singleAggregationProvider(): array
+    {
+        return [
+            'count all products' => ['cnt', 'count', '*', 'total', [], 9],
+            'count electronics' => ['cnt', 'count', '*', 'total', [Query::equal('category', ['electronics'])], 3],
+            'count clothing' => ['cnt', 'count', '*', 'total', [Query::equal('category', ['clothing'])], 3],
+            'count books' => ['cnt', 'count', '*', 'total', [Query::equal('category', ['books'])], 3],
+            'count price > 100' => ['cnt', 'count', '*', 'total', [Query::greaterThan('price', 100)], 4],
+            'count price <= 50' => ['cnt', 'count', '*', 'total', [Query::lessThanEqual('price', 50)], 4],
+            'sum all prices' => ['sum', 'sum', 'price', 'total', [], 2785],
+            'sum electronics' => ['sum', 'sum', 'price', 'total', [Query::equal('category', ['electronics'])], 2500],
+            'sum clothing' => ['sum', 'sum', 'price', 'total', [Query::equal('category', ['clothing'])], 200],
+            'sum books' => ['sum', 'sum', 'price', 'total', [Query::equal('category', ['books'])], 85],
+            'sum stock' => ['sum', 'sum', 'stock', 'total', [], 1495],
+            'sum stock electronics' => ['sum', 'sum', 'stock', 'total', [Query::equal('category', ['electronics'])], 225],
+            'min all price' => ['min', 'min', 'price', 'val', [], 10],
+            'min electronics price' => ['min', 'min', 'price', 'val', [Query::equal('category', ['electronics'])], 500],
+            'min clothing price' => ['min', 'min', 'price', 'val', [Query::equal('category', ['clothing'])], 30],
+            'min books price' => ['min', 'min', 'price', 'val', [Query::equal('category', ['books'])], 10],
+            'min stock' => ['min', 'min', 'stock', 'val', [], 40],
+            'max all price' => ['max', 'max', 'price', 'val', [], 1200],
+            'max electronics price' => ['max', 'max', 'price', 'val', [Query::equal('category', ['electronics'])], 1200],
+            'max clothing price' => ['max', 'max', 'price', 'val', [Query::equal('category', ['clothing'])], 120],
+            'max books price' => ['max', 'max', 'price', 'val', [Query::equal('category', ['books'])], 60],
+            'max stock' => ['max', 'max', 'stock', 'val', [], 500],
+            'count distinct categories' => ['cntd', 'countDistinct', 'category', 'val', [], 3],
+            'count distinct price > 50' => ['cntd', 'countDistinct', 'category', 'val', [Query::greaterThan('price', 50)], 3],
+        ];
+    }
+
+    /**
+     * @param  array<Query>  $filters
+     */
+    #[DataProvider('singleAggregationProvider')]
+    public function testSingleAggregation(string $collSuffix, string $method, string $attribute, string $alias, array $filters, int|float $expected): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_agg_' . $collSuffix . $this->getAggSuffix();
+        $this->createProducts($database, $col);
+
+        $aggQuery = match ($method) {
+            'count' => Query::count($attribute, $alias),
+            'sum' => Query::sum($attribute, $alias),
+            'avg' => Query::avg($attribute, $alias),
+            'min' => Query::min($attribute, $alias),
+            'max' => Query::max($attribute, $alias),
+            'countDistinct' => Query::countDistinct($attribute, $alias),
+            default => throw new \InvalidArgumentException('Unknown aggregation method: '.$method),
+        };
+
+        $queries = array_merge($filters, [$aggQuery]);
+        $results = $database->find($col, $queries);
+        $this->assertCount(1, $results);
+
+        if ($method === 'avg') {
+            $this->assertEqualsWithDelta($expected, $this->numericAttribute($results[0], $alias), 1.0);
+        } else {
+            $this->assertEquals($expected, $results[0]->getAttribute($alias));
+        }
+    }
+
+    /**
+     * @return array<string, array{string, array<Query>, int}>
+     */
+    public static function groupByCountProvider(): array
+    {
+        return [
+            'group by category no filter' => ['category', [], 3],
+            'group by category price > 50' => ['category', [Query::greaterThan('price', 50)], 3],
+            'group by category price > 200' => ['category', [Query::greaterThan('price', 200)], 1],
+        ];
+    }
+
+    /**
+     * @param  array<Query>  $filters
+     */
+    #[DataProvider('groupByCountProvider')]
+    public function testGroupByCount(string $groupCol, array $filters, int $expectedGroups): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_grpby' . $this->getAggSuffix();
+        $this->createProducts($database, $col);
+
+        $queries = array_merge($filters, [
+            Query::count('*', 'cnt'),
+            Query::groupBy([$groupCol]),
+        ]);
+        $results = $database->find($col, $queries);
+        $this->assertCount($expectedGroups, $results);
+    }
+
+    /**
+     * @return array<string, array{string, int}>
+     */
+    public static function orderStatusAggProvider(): array
+    {
+        return [
+            'completed orders revenue' => ['completed', 4615],
+            'pending orders revenue' => ['pending', 890],
+            'cancelled orders revenue' => ['cancelled', 500],
+        ];
+    }
+
+    #[DataProvider('orderStatusAggProvider')]
+    public function testOrderStatusAggregation(string $status, int $expectedRevenue): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_osa_' . $status;
+        $this->createOrders($database, $col);
+
+        $results = $database->find($col, [
+            Query::equal('status', [$status]),
+            Query::sum('total', 'revenue'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals($expectedRevenue, $results[0]->getAttribute('revenue'));
+        $database->deleteCollection($col);
+    }
+
+    /**
+     * @return array<string, array{string, string, int|float}>
+     */
+    public static function categoryAggProvider(): array
+    {
+        return [
+            'electronics count' => ['electronics', 'count', 3],
+            'electronics sum' => ['electronics', 'sum', 2500],
+            'electronics min' => ['electronics', 'min', 500],
+            'electronics max' => ['electronics', 'max', 1200],
+            'clothing count' => ['clothing', 'count', 3],
+            'clothing sum' => ['clothing', 'sum', 200],
+            'clothing min' => ['clothing', 'min', 30],
+            'clothing max' => ['clothing', 'max', 120],
+            'books count' => ['books', 'count', 3],
+            'books sum' => ['books', 'sum', 85],
+            'books min' => ['books', 'min', 10],
+            'books max' => ['books', 'max', 60],
+        ];
+    }
+
+    #[DataProvider('categoryAggProvider')]
+    public function testCategoryAggregation(string $category, string $method, int|float $expected): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_cat_' . $category . '_' . $method;
+        $this->createProducts($database, $col);
+
+        $aggQuery = match ($method) {
+            'count' => Query::count('*', 'val'),
+            'sum' => Query::sum('price', 'val'),
+            'min' => Query::min('price', 'val'),
+            'max' => Query::max('price', 'val'),
+            default => throw new \InvalidArgumentException('Unknown aggregation method: '.$method),
+        };
+
+        $results = $database->find($col, [
+            Query::equal('category', [$category]),
+            $aggQuery,
+        ]);
+        $this->assertEquals($expected, $results[0]->getAttribute('val'));
+        $database->deleteCollection($col);
+    }
+
+    /**
+     * @return array<string, array{string, int}>
+     */
+    public static function reviewCountProvider(): array
+    {
+        return [
+            'laptop reviews' => ['laptop', 3],
+            'phone reviews' => ['phone', 2],
+            'shirt reviews' => ['shirt', 2],
+            'novel reviews' => ['novel', 3],
+            'jacket reviews' => ['jacket', 1],
+            'textbook reviews' => ['textbook', 1],
+        ];
+    }
+
+    #[DataProvider('reviewCountProvider')]
+    public function testReviewCounts(string $productId, int $expectedCount): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_rc_' . $productId;
+        $this->createReviews($database, $col);
+
+        $results = $database->find($col, [
+            Query::equal('product_uid', [$productId]),
+            Query::count('*', 'cnt'),
+        ]);
+        $this->assertEquals($expectedCount, $results[0]->getAttribute('cnt'));
+        $database->deleteCollection($col);
+    }
+
+    /**
+     * @return array<string, array{int, int}>
+     */
+    public static function priceRangeCountProvider(): array
+    {
+        return [
+            'price 0-20' => [0, 20, 2],
+            'price 0-50' => [0, 50, 4],
+            'price 0-100' => [0, 100, 5],
+            'price 50-200' => [50, 200, 3],
+            'price 100-500' => [100, 500, 2],
+            'price 500-1500' => [500, 1500, 3],
+            'price 0-10000' => [0, 10000, 9],
+        ];
+    }
+
+    #[DataProvider('priceRangeCountProvider')]
+    public function testPriceRangeCount(int $min, int $max, int $expected): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $col = 'dp_prc_' . $min . '_' . $max;
+        $this->createProducts($database, $col);
+
+        $results = $database->find($col, [
+            Query::between('price', $min, $max),
+            Query::count('*', 'cnt'),
+        ]);
+        $this->assertEquals($expected, $results[0]->getAttribute('cnt'));
+        $database->deleteCollection($col);
+    }
+
+    public function testStddevPopOfPrice(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'stddev_pop');
+        $results = $database->find('stddev_pop', [Query::stddevPop('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertEqualsWithDelta(406.87456737949, $this->numericAttribute($results[0], 'result'), 0.5);
+        $database->deleteCollection('stddev_pop');
+    }
+
+    public function testStddevSampOfPrice(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'stddev_samp');
+        $results = $database->find('stddev_samp', [Query::stddevSamp('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertEqualsWithDelta(431.55564852957, $this->numericAttribute($results[0], 'result'), 0.5);
+        $database->deleteCollection('stddev_samp');
+    }
+
+    public function testVarPopOfPrice(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'var_pop');
+        $results = $database->find('var_pop', [Query::varPop('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertEqualsWithDelta(165546.91358025, $this->numericAttribute($results[0], 'result'), 1.0);
+        $database->deleteCollection('var_pop');
+    }
+
+    public function testVarSampOfPrice(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'var_samp');
+        $results = $database->find('var_samp', [Query::varSamp('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertEqualsWithDelta(186240.27777778, $this->numericAttribute($results[0], 'result'), 1.0);
+        $database->deleteCollection('var_samp');
+    }
+
+    public function testBitAndOfIntegerColumn(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'bit_and');
+        $results = $database->find('bit_and', [Query::bitAnd('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertSame(0, $this->intAttribute($results[0], 'result'));
+        $database->deleteCollection('bit_and');
+    }
+
+    public function testBitOrOfIntegerColumn(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'bit_or');
+        $results = $database->find('bit_or', [Query::bitOr('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertSame(2047, $this->intAttribute($results[0], 'result'));
+        $database->deleteCollection('bit_or');
+    }
+
+    public function testBitXorOfIntegerColumn(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Aggregations) || $database->getAdapter() instanceof SQLite) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $this->createProducts($database, 'bit_xor');
+        $results = $database->find('bit_xor', [Query::bitXor('price', 'result')]);
+        $this->assertCount(1, $results);
+        $this->assertSame(1545, $this->intAttribute($results[0], 'result'));
+        $database->deleteCollection('bit_xor');
+    }
+
+}
diff --git a/tests/e2e/Adapter/Scopes/AttributeTests.php b/tests/e2e/Adapter/Scopes/AttributeTests.php
index 8f68ea8243..62595b6da4 100644
--- a/tests/e2e/Adapter/Scopes/AttributeTests.php
+++ b/tests/e2e/Adapter/Scopes/AttributeTests.php
@@ -4,6 +4,10 @@
 
 use Exception;
 use Throwable;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -19,51 +23,106 @@
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
 use Utopia\Database\Validator\Datetime as DatetimeValidator;
 use Utopia\Database\Validator\Structure;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\Order;
 use Utopia\Validator\Range;
 
 trait AttributeTests
 {
+    private static string $attributesCollection = '';
+
+    private static string $flowersCollection = '';
+
+    private static string $colorsCollection = '';
+
+    protected function getAttributesCollection(): string
+    {
+        if (self::$attributesCollection === '') {
+            self::$attributesCollection = 'attributes_' . uniqid();
+        }
+        return self::$attributesCollection;
+    }
+
+    protected function getFlowersCollection(): string
+    {
+        if (self::$flowersCollection === '') {
+            self::$flowersCollection = 'flowers_' . uniqid();
+        }
+        return self::$flowersCollection;
+    }
+
+    protected function getColorsCollection(): string
+    {
+        if (self::$colorsCollection === '') {
+            self::$colorsCollection = 'colors_' . uniqid();
+        }
+        return self::$colorsCollection;
+    }
+
     private function createRandomString(int $length = 10): string
     {
         return \substr(\bin2hex(\random_bytes(\max(1, \intval(($length + 1) / 2)))), 0, $length);
     }
 
+    /**
+     * @param  array<string, mixed>  $attribute
+     */
+    private function priceRangeFormat(array $attribute): Range
+    {
+        $formatOptions = $attribute['formatOptions'] ?? [];
+        if (! is_array($formatOptions)) {
+            $formatOptions = [];
+        }
+        $min = $formatOptions['min'] ?? 0;
+        $max = $formatOptions['max'] ?? 0;
+        if (! is_numeric($min)) {
+            $min = 0;
+        }
+        if (! is_numeric($max)) {
+            $max = 0;
+        }
+
+        return new Range((float) $min, (float) $max);
+    }
+
     /**
      * Using phpunit dataProviders to check that all these combinations of types/defaults throw exceptions
      * https://phpunit.de/manual/3.7/en/writing-tests-for-phpunit.html#writing-tests-for-phpunit.data-providers
      *
-     * @return array<array<bool|float|int|string>>
+     * @return list<array{0: ColumnType, 1: bool|float|int|string}>
      */
     public function invalidDefaultValues(): array
     {
         return [
-            [Database::VAR_STRING, 1],
-            [Database::VAR_STRING, 1.5],
-            [Database::VAR_STRING, false],
-            [Database::VAR_INTEGER, "one"],
-            [Database::VAR_INTEGER, 1.5],
-            [Database::VAR_INTEGER, true],
-            [Database::VAR_FLOAT, 1],
-            [Database::VAR_FLOAT, "one"],
-            [Database::VAR_FLOAT, false],
-            [Database::VAR_BOOLEAN, 0],
-            [Database::VAR_BOOLEAN, "false"],
-            [Database::VAR_BOOLEAN, 0.5],
-            [Database::VAR_VARCHAR, 1],
-            [Database::VAR_VARCHAR, 1.5],
-            [Database::VAR_VARCHAR, false],
-            [Database::VAR_TEXT, 1],
-            [Database::VAR_TEXT, 1.5],
-            [Database::VAR_TEXT, true],
-            [Database::VAR_MEDIUMTEXT, 1],
-            [Database::VAR_MEDIUMTEXT, 1.5],
-            [Database::VAR_MEDIUMTEXT, false],
-            [Database::VAR_LONGTEXT, 1],
-            [Database::VAR_LONGTEXT, 1.5],
-            [Database::VAR_LONGTEXT, true],
+            [ColumnType::String, 1],
+            [ColumnType::String, 1.5],
+            [ColumnType::String, false],
+            [ColumnType::Integer, 'one'],
+            [ColumnType::Integer, 1.5],
+            [ColumnType::Integer, true],
+            [ColumnType::Double, 1],
+            [ColumnType::Double, 'one'],
+            [ColumnType::Double, false],
+            [ColumnType::Boolean, 0],
+            [ColumnType::Boolean, 'false'],
+            [ColumnType::Boolean, 0.5],
+            [ColumnType::Varchar, 1],
+            [ColumnType::Varchar, 1.5],
+            [ColumnType::Varchar, false],
+            [ColumnType::Text, 1],
+            [ColumnType::Text, 1.5],
+            [ColumnType::Text, true],
+            [ColumnType::MediumText, 1],
+            [ColumnType::MediumText, 1.5],
+            [ColumnType::MediumText, false],
+            [ColumnType::LongText, 1],
+            [ColumnType::LongText, 1.5],
+            [ColumnType::LongText, true],
         ];
     }
 
@@ -72,173 +131,169 @@ public function testCreateDeleteAttribute(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('attributes');
+        $database->createCollection(new Collection(id: $this->getAttributesCollection()));
 
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string1', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string2', Database::VAR_STRING, 16382 + 1, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string3', Database::VAR_STRING, 65535 + 1, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string4', Database::VAR_STRING, 16777215 + 1, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'integer', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'bigint', Database::VAR_INTEGER, 8, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'float', Database::VAR_FLOAT, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'boolean', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'id', Database::VAR_ID, 0, true));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string1', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string2', size: 16382 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string3', size: 65535 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string4', size: 16777215 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::integer(key: 'integer', required: true)));
+        $this->assertTrue($database->createAttribute($this->getAttributesCollection(), Attribute::bigInteger(key: 'bigint', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::double(key: 'float', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'boolean', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::id(key: 'id', required: true)));
 
         // New string types
-        $this->assertEquals(true, $database->createAttribute('attributes', 'varchar1', Database::VAR_VARCHAR, 255, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'varchar2', Database::VAR_VARCHAR, 128, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'text1', Database::VAR_TEXT, 65535, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'mediumtext1', Database::VAR_MEDIUMTEXT, 16777215, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'longtext1', Database::VAR_LONGTEXT, 4294967295, true));
-
-        $this->assertEquals(true, $database->createIndex('attributes', 'id_index', Database::INDEX_KEY, ['id']));
-        $this->assertEquals(true, $database->createIndex('attributes', 'string1_index', Database::INDEX_KEY, ['string1']));
-        $this->assertEquals(true, $database->createIndex('attributes', 'string2_index', Database::INDEX_KEY, ['string2'], [255]));
-        $this->assertEquals(true, $database->createIndex('attributes', 'multi_index', Database::INDEX_KEY, ['string1', 'string2', 'string3'], [128, 128, 128]));
-        $this->assertEquals(true, $database->createIndex('attributes', 'varchar1_index', Database::INDEX_KEY, ['varchar1']));
-        $this->assertEquals(true, $database->createIndex('attributes', 'varchar2_index', Database::INDEX_KEY, ['varchar2']));
-        $this->assertEquals(true, $database->createIndex('attributes', 'text1_index', Database::INDEX_KEY, ['text1'], [255]));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(14, $collection->getAttribute('attributes'));
-        $this->assertCount(7, $collection->getAttribute('indexes'));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::varchar(key: 'varchar1', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::varchar(key: 'varchar2', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::text(key: 'text1', size: 65535, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::mediumText(key: 'mediumtext1', size: 16777215, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::longText(key: 'longtext1', size: 4294967295, required: true)));
+
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'id_index', attributes: ['id'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'string1_index', attributes: ['string1'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'string2_index', attributes: ['string2'], lengths: [255])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'multi_index', attributes: ['string1', 'string2', 'string3'], lengths: [128, 128, 128])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'varchar1_index', attributes: ['varchar1'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'varchar2_index', attributes: ['varchar2'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), Index::key(key: 'text1_index', attributes: ['text1'], lengths: [255])));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(14, $collection->attributes);
+        $this->assertCount(7, $collection->indexes);
 
         // Array
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string_list', Database::VAR_STRING, 128, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'integer_list', Database::VAR_INTEGER, 0, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'float_list', Database::VAR_FLOAT, 0, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'boolean_list', Database::VAR_BOOLEAN, 0, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'varchar_list', Database::VAR_VARCHAR, 128, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'text_list', Database::VAR_TEXT, 65535, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'mediumtext_list', Database::VAR_MEDIUMTEXT, 16777215, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'longtext_list', Database::VAR_LONGTEXT, 4294967295, true, null, true, true));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(22, $collection->getAttribute('attributes'));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string_list', size: 128, required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::integer(key: 'integer_list', required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::double(key: 'float_list', required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'boolean_list', required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::varchar(key: 'varchar_list', size: 128, required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::text(key: 'text_list', size: 65535, required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::mediumText(key: 'mediumtext_list', size: 16777215, required: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::longText(key: 'longtext_list', size: 4294967295, required: true, array: true)));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(22, $collection->attributes);
 
         // Default values
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string_default', Database::VAR_STRING, 256, false, 'test'));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'integer_default', Database::VAR_INTEGER, 0, false, 1));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'float_default', Database::VAR_FLOAT, 0, false, 1.5));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'boolean_default', Database::VAR_BOOLEAN, 0, false, false));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'datetime_default', Database::VAR_DATETIME, 0, false, '2000-06-12T14:12:55.000+00:00', true, false, null, [], ['datetime']));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'varchar_default', Database::VAR_VARCHAR, 255, false, 'varchar default'));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'text_default', Database::VAR_TEXT, 65535, false, 'text default'));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'mediumtext_default', Database::VAR_MEDIUMTEXT, 16777215, false, 'mediumtext default'));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'longtext_default', Database::VAR_LONGTEXT, 4294967295, false, 'longtext default'));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(31, $collection->getAttribute('attributes'));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string_default', size: 256, default: 'test')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::integer(key: 'integer_default', default: 1)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::double(key: 'float_default', default: 1.5)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'boolean_default', default: false)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::datetime(key: 'datetime_default', default: '2000-06-12T14:12:55.000+00:00', filters: ['datetime'])));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::varchar(key: 'varchar_default', default: 'varchar default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::text(key: 'text_default', size: 65535, default: 'text default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::mediumText(key: 'mediumtext_default', size: 16777215, default: 'mediumtext default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::longText(key: 'longtext_default', size: 4294967295, default: 'longtext default')));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(31, $collection->attributes);
 
         // Delete
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string1'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string2'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string3'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string4'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'integer'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'bigint'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'float'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'boolean'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'id'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'varchar1'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'varchar2'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'text1'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'mediumtext1'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'longtext1'));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(17, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string2'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string3'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string4'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'integer'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'bigint'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'float'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'boolean'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'id'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'varchar1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'varchar2'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'text1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'mediumtext1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'longtext1'));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(17, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
 
         // Delete Array
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'integer_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'float_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'boolean_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'varchar_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'text_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'mediumtext_list'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'longtext_list'));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(9, $collection->getAttribute('attributes'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'integer_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'float_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'boolean_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'varchar_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'text_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'mediumtext_list'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'longtext_list'));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(9, $collection->attributes);
 
         // Delete default
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'integer_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'float_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'boolean_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'datetime_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'varchar_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'text_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'mediumtext_default'));
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'longtext_default'));
-
-        $collection = $database->getCollection('attributes');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'integer_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'float_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'boolean_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'datetime_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'varchar_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'text_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'mediumtext_default'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'longtext_default'));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $this->assertCount(0, $collection->attributes);
 
         // Test for custom chars in ID
-        $this->assertEquals(true, $database->createAttribute('attributes', 'as_5dasdasdas', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'as5dasdasdas_', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', '.as5dasdasdas', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', '-as5dasdasdas', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'as-5dasdasdas', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'as5dasdasdas-', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', 'socialAccountForYoutubeSubscribersss', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('attributes', '5f058a89258075f058a89258075f058t9214', Database::VAR_BOOLEAN, 0, true));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'as_5dasdasdas', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'as5dasdasdas_', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: '.as5dasdasdas', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: '-as5dasdasdas', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'as-5dasdasdas', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'as5dasdasdas-', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: 'socialAccountForYoutubeSubscribersss', required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::boolean(key: '5f058a89258075f058a89258075f058t9214', required: true)));
 
         // Test non-shared tables duplicates throw duplicate
-        $database->createAttribute('attributes', 'duplicate', Database::VAR_STRING, 128, true);
+        $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'duplicate', size: 128, required: true));
         try {
-            $database->createAttribute('attributes', 'duplicate', Database::VAR_STRING, 128, true);
+            $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'duplicate', size: 128, required: true));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
             $this->assertInstanceOf(DuplicateException::class, $e);
         }
 
         // Test delete attribute when column does not exist
-        $this->assertEquals(true, $database->createAttribute('attributes', 'string1', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), Attribute::string(key: 'string1', size: 128, required: true)));
         sleep(1);
 
-        $this->assertEquals(true, $this->deleteColumn('attributes', 'string1'));
+        $this->assertEquals(true, $this->deleteColumn($this->getAttributesCollection(), 'string1'));
 
-        $collection = $database->getCollection('attributes');
-        $attributes = $collection->getAttribute('attributes');
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $attributes = $collection->attributes;
         $attribute = end($attributes);
+        $this->assertInstanceOf(Attribute::class, $attribute);
         $this->assertEquals('string1', $attribute->getId());
 
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string1'));
 
-        $collection = $database->getCollection('attributes');
-        $attributes = $collection->getAttribute('attributes');
+        $collection = $database->getCollection($this->getAttributesCollection());
+        $attributes = $collection->attributes;
         $attribute = end($attributes);
+        $this->assertInstanceOf(Attribute::class, $attribute);
         $this->assertNotEquals('string1', $attribute->getId());
 
-        $collection = $database->getCollection('attributes');
+        $collection = $database->getCollection($this->getAttributesCollection());
     }
+
     /**
-     * @depends      testCreateDeleteAttribute
-     * @dataProvider invalidDefaultValues
+     * Sets up the 'attributes' collection for tests that depend on testCreateDeleteAttribute.
      */
-    public function testInvalidDefaultValues(string $type, mixed $default): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+    private static bool $attributesCollectionFixtureInit = false;
 
-        $this->expectException(\Exception::class);
-        $this->assertEquals(false, $database->createAttribute('attributes', 'bad_default', $type, 256, true, $default));
-    }
-    /**
-    * @depends testInvalidDefaultValues
-    */
-    public function testAttributeCaseInsensitivity(): void
+    protected function initAttributesCollectionFixture(): void
     {
-        /** @var Database $database */
+        if (self::$attributesCollectionFixtureInit) {
+            return;
+        }
+
         $database = $this->getDatabase();
 
-        $this->assertEquals(true, $database->createAttribute('attributes', 'caseSensitive', Database::VAR_STRING, 128, true));
-        $this->expectException(DuplicateException::class);
-        $this->assertEquals(true, $database->createAttribute('attributes', 'CaseSensitive', Database::VAR_STRING, 128, true));
+        $database->createCollection(new Collection(id: $this->getAttributesCollection()));
+
+        self::$attributesCollectionFixtureInit = true;
     }
 
     public function testAttributeKeyWithSymbols(): void
@@ -246,15 +301,15 @@ public function testAttributeKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('attributesWithKeys');
+        $database->createCollection(new Collection(id: 'attributesWithKeys'));
 
-        $this->assertEquals(true, $database->createAttribute('attributesWithKeys', 'key_with.sym$bols', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('attributesWithKeys', Attribute::string(key: 'key_with.sym$bols', size: 128, required: true)));
 
         $document = $database->createDocument('attributesWithKeys', new Document([
             'key_with.sym$bols' => 'value',
             '$permissions' => [
                 Permission::read(Role::any()),
-            ]
+            ],
         ]));
 
         $this->assertEquals('value', $document->getAttribute('key_with.sym$bols'));
@@ -266,39 +321,28 @@ public function testAttributeKeyWithSymbols(): void
 
     public function testAttributeNamesWithDots(): void
     {
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('dots.parent');
+        $database->createCollection(new Collection(id: 'dots.parent'));
 
-        $this->assertTrue($database->createAttribute(
-            collection: 'dots.parent',
-            id: 'dots.name',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
+        $this->assertTrue($database->createAttribute('dots.parent', Attribute::string(key: 'dots.name')));
 
         $document = $database->find('dots.parent', [
             Query::select(['dots.name']),
         ]);
         $this->assertEmpty($document);
 
-        $database->createCollection('dots');
+        $database->createCollection(new Collection(id: 'dots'));
 
-        $this->assertTrue($database->createAttribute(
-            collection: 'dots',
-            id: 'name',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
+        $this->assertTrue($database->createAttribute('dots', Attribute::string(key: 'name')));
 
-        $database->createRelationship(
-            collection: 'dots.parent',
-            relatedCollection: 'dots',
-            type: Database::RELATION_ONE_TO_ONE
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'dots.parent', relatedCollection: 'dots'));
 
         $database->createDocument('dots.parent', new Document([
             '$id' => ID::custom('father'),
@@ -317,7 +361,7 @@ public function testAttributeNamesWithDots(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-            ]
+            ],
         ]));
 
         $documents = $database->find('dots.parent', [
@@ -327,18 +371,18 @@ public function testAttributeNamesWithDots(): void
         $this->assertEquals('Bill clinton', $documents[0]['dots.name']);
     }
 
-
     public function testUpdateAttributeDefault(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
+        $collection = $this->getFlowersCollection();
 
-        $flowers = $database->createCollection('flowers');
-        $database->createAttribute('flowers', 'name', Database::VAR_STRING, 128, true);
-        $database->createAttribute('flowers', 'inStock', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute('flowers', 'date', Database::VAR_STRING, 128, false);
+        $flowers = $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'inStock'));
+        $database->createAttribute($collection, Attribute::string(key: 'date', size: 128));
 
-        $database->createDocument('flowers', new Document([
+        $database->createDocument($collection, new Document([
             '$id' => 'flowerWithDate',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -348,52 +392,53 @@ public function testUpdateAttributeDefault(): void
             ],
             'name' => 'Violet',
             'inStock' => 51,
-            'date' => '2000-06-12 14:12:55.000'
+            'date' => '2000-06-12 14:12:55.000',
         ]));
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($collection, new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Lily'
+            'name' => 'Lily',
         ]));
 
+        self::$flowersFixtureInit = true;
+
         $this->assertNull($doc->getAttribute('inStock'));
 
-        $database->updateAttributeDefault('flowers', 'inStock', 100);
+        $database->updateAttributeDefault($this->getFlowersCollection(), 'inStock', 100);
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Iris'
+            'name' => 'Iris',
         ]));
 
         $this->assertIsNumeric($doc->getAttribute('inStock'));
         $this->assertEquals(100, $doc->getAttribute('inStock'));
 
-        $database->updateAttributeDefault('flowers', 'inStock', null);
+        $database->updateAttributeDefault($this->getFlowersCollection(), 'inStock', null);
     }
 
-
     public function testRenameAttribute(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $colors = $database->createCollection('colors');
-        $database->createAttribute('colors', 'name', Database::VAR_STRING, 128, true);
-        $database->createAttribute('colors', 'hex', Database::VAR_STRING, 128, true);
+        $colors = $database->createCollection(new Collection(id: $this->getColorsCollection()));
+        $database->createAttribute($this->getColorsCollection(), Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($this->getColorsCollection(), Attribute::string(key: 'hex', size: 128, required: true));
 
-        $database->createIndex('colors', 'index1', Database::INDEX_KEY, ['name'], [128], [Database::ORDER_ASC]);
+        $database->createIndex($this->getColorsCollection(), Index::key(key: 'index1', attributes: ['name'], lengths: [128], orders: [Order::Asc]));
 
-        $database->createDocument('colors', new Document([
+        $database->createDocument($this->getColorsCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -401,70 +446,115 @@ public function testRenameAttribute(): void
                 Permission::delete(Role::any()),
             ],
             'name' => 'black',
-            'hex' => '#000000'
+            'hex' => '#000000',
         ]));
 
-        $attribute = $database->renameAttribute('colors', 'name', 'verbose');
+        $attribute = $database->renameAttribute($this->getColorsCollection(), 'name', 'verbose');
 
         $this->assertTrue($attribute);
 
-        $colors = $database->getCollection('colors');
-        $this->assertEquals('hex', $colors->getAttribute('attributes')[1]['$id']);
-        $this->assertEquals('verbose', $colors->getAttribute('attributes')[0]['$id']);
-        $this->assertCount(2, $colors->getAttribute('attributes'));
+        $colors = $database->getCollection($this->getColorsCollection());
+        $this->assertEquals('hex', $colors->attributes[1]['$id']);
+        $this->assertEquals('verbose', $colors->attributes[0]['$id']);
+        $this->assertCount(2, $colors->attributes);
 
         // Attribute in index is renamed automatically on adapter-level. What we need to check is if metadata is properly updated
-        $this->assertEquals('verbose', $colors->getAttribute('indexes')[0]->getAttribute("attributes")[0]);
-        $this->assertCount(1, $colors->getAttribute('indexes'));
+        $this->assertEquals('verbose', $colors->indexes[0]->attributes[0]);
+        $this->assertCount(1, $colors->indexes);
 
         // Document should be there if adapter migrated properly
-        $document = $database->findOne('colors');
+        $document = $database->findOne($this->getColorsCollection());
         $this->assertFalse($document->isEmpty());
         $this->assertEquals('black', $document->getAttribute('verbose'));
         $this->assertEquals('#000000', $document->getAttribute('hex'));
         $this->assertEquals(null, $document->getAttribute('name'));
-    }
 
+        self::$colorsFixtureInit = true;
+    }
 
     /**
-     * @depends testUpdateAttributeDefault
+     * Sets up the 'flowers' collection for tests that depend on testUpdateAttributeDefault.
      */
+    private static bool $flowersFixtureInit = false;
+
+    protected function initFlowersFixture(): void
+    {
+        if (self::$flowersFixtureInit) {
+            return;
+        }
+
+        $database = $this->getDatabase();
+
+        $collection = $this->getFlowersCollection();
+        $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'inStock'));
+        $database->createAttribute($collection, Attribute::string(key: 'date', size: 128));
+
+        $database->createDocument($collection, new Document([
+            '$id' => 'flowerWithDate',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => 'Violet',
+            'inStock' => 51,
+            'date' => '2000-06-12 14:12:55.000',
+        ]));
+
+        $database->createDocument($collection, new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => 'Lily',
+        ]));
+
+        self::$flowersFixtureInit = true;
+    }
+
     public function testUpdateAttributeRequired(): void
     {
+        $this->initFlowersFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->updateAttributeRequired('flowers', 'inStock', true);
+        $database->updateAttributeRequired($this->getFlowersCollection(), 'inStock', true);
 
         $this->expectExceptionMessage('Invalid document structure: Missing required attribute "inStock"');
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Lily With Missing Stocks'
+            'name' => 'Lily With Missing Stocks',
         ]));
     }
 
-    /**
-     * @depends testUpdateAttributeDefault
-     */
     public function testUpdateAttributeFilter(): void
     {
+        $this->initFlowersFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createAttribute('flowers', 'cartModel', Database::VAR_STRING, 2000, false);
+        $database->createAttribute($this->getFlowersCollection(), Attribute::string(key: 'cartModel', size: 2000));
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -473,37 +563,44 @@ public function testUpdateAttributeFilter(): void
             ],
             'name' => 'Lily With CartData',
             'inStock' => 50,
-            'cartModel' => '{"color":"string","size":"number"}'
+            'cartModel' => '{"color":"string","size":"number"}',
         ]));
 
         $this->assertIsString($doc->getAttribute('cartModel'));
         $this->assertEquals('{"color":"string","size":"number"}', $doc->getAttribute('cartModel'));
 
-        $database->updateAttributeFilters('flowers', 'cartModel', ['json']);
+        $database->updateAttributeFilters($this->getFlowersCollection(), 'cartModel', ['json']);
 
-        $doc = $database->getDocument('flowers', $doc->getId());
+        $doc = $database->getDocument($this->getFlowersCollection(), $doc->getId());
         $this->assertIsArray($doc->getAttribute('cartModel'));
         $this->assertCount(2, $doc->getAttribute('cartModel'));
         $this->assertEquals('string', $doc->getAttribute('cartModel')['color']);
         $this->assertEquals('number', $doc->getAttribute('cartModel')['size']);
     }
 
-    /**
-     * @depends testUpdateAttributeDefault
-     */
     public function testUpdateAttributeFormat(): void
     {
+        $this->initFlowersFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createAttribute('flowers', 'price', Database::VAR_INTEGER, 0, false);
+        // Ensure cartModel attribute exists (created by testUpdateAttributeFilter in sequential mode)
+        try {
+            $database->createAttribute($this->getFlowersCollection(), Attribute::string(key: 'cartModel', size: 2000));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        $database->createAttribute($this->getFlowersCollection(), Attribute::integer(key: 'price'));
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -514,25 +611,20 @@ public function testUpdateAttributeFormat(): void
             'name' => 'Lily Priced',
             'inStock' => 50,
             'cartModel' => '{}',
-            'price' => 500
+            'price' => 500,
         ]));
 
         $this->assertIsNumeric($doc->getAttribute('price'));
         $this->assertEquals(500, $doc->getAttribute('price'));
 
-        Structure::addFormat('priceRange', function ($attribute) {
-            $min = $attribute['formatOptions']['min'];
-            $max = $attribute['formatOptions']['max'];
+        Structure::addFormat('priceRange', $this->priceRangeFormat(...), ColumnType::Integer);
 
-            return new Range($min, $max);
-        }, Database::VAR_INTEGER);
-
-        $database->updateAttributeFormat('flowers', 'price', 'priceRange');
-        $database->updateAttributeFormatOptions('flowers', 'price', ['min' => 1, 'max' => 10000]);
+        $database->updateAttributeFormat($this->getFlowersCollection(), 'price', 'priceRange');
+        $database->updateAttributeFormatOptions($this->getFlowersCollection(), 'price', ['min' => 1, 'max' => 10000]);
 
         $this->expectExceptionMessage('Invalid document structure: Attribute "price" has invalid format. Value must be a valid range between 1 and 10,000');
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -542,30 +634,81 @@ public function testUpdateAttributeFormat(): void
             'name' => 'Lily Overpriced',
             'inStock' => 50,
             'cartModel' => '{}',
-            'price' => 15000
+            'price' => 15000,
         ]));
     }
 
     /**
-     * @depends testUpdateAttributeDefault
-     * @depends testUpdateAttributeFormat
+     * Sets up the 'flowers' collection with price attribute and priceRange format
+     * as testUpdateAttributeFormat would leave it.
      */
+    private static bool $flowersWithPriceFixtureInit = false;
+
+    protected function initFlowersWithPriceFixture(): void
+    {
+        if (self::$flowersWithPriceFixtureInit) {
+            return;
+        }
+
+        $this->initFlowersFixture();
+
+        $database = $this->getDatabase();
+
+        // Add cartModel attribute (from testUpdateAttributeFilter)
+        try {
+            $database->createAttribute($this->getFlowersCollection(), Attribute::string(key: 'cartModel', size: 2000));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        // Add price attribute and set format (from testUpdateAttributeFormat)
+        try {
+            $database->createAttribute($this->getFlowersCollection(), Attribute::integer(key: 'price'));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        // Create LiliPriced document if it doesn't exist
+        try {
+            $database->createDocument($this->getFlowersCollection(), new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                '$id' => ID::custom('LiliPriced'),
+                'name' => 'Lily Priced',
+                'inStock' => 50,
+                'cartModel' => '{}',
+                'price' => 500,
+            ]));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        Structure::addFormat('priceRange', $this->priceRangeFormat(...), ColumnType::Integer);
+
+        $database->updateAttributeFormat($this->getFlowersCollection(), 'price', 'priceRange');
+        $database->updateAttributeFormatOptions($this->getFlowersCollection(), 'price', ['min' => 1, 'max' => 10000]);
+
+        self::$flowersWithPriceFixtureInit = true;
+    }
+
     public function testUpdateAttributeStructure(): void
     {
+        $this->initFlowersWithPriceFixture();
+
         // TODO: When this becomes relevant, add many more tests (from all types to all types, chaging size up&down, switchign between array/non-array...
 
-        Structure::addFormat('priceRangeNew', function ($attribute) {
-            $min = $attribute['formatOptions']['min'];
-            $max = $attribute['formatOptions']['max'];
-            return new Range($min, $max);
-        }, Database::VAR_INTEGER);
+        Structure::addFormat('priceRangeNew', $this->priceRangeFormat(...), ColumnType::Integer);
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
         // price attribute
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
         $this->assertEquals(null, $attribute['default']);
@@ -574,9 +717,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('priceRange', $attribute['format']);
         $this->assertEquals(['min' => 1, 'max' => 10000], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', default: 100);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', default: 100);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -586,9 +729,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('priceRange', $attribute['format']);
         $this->assertEquals(['min' => 1, 'max' => 10000], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', format: 'priceRangeNew');
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', format: 'priceRangeNew');
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -598,9 +741,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('priceRangeNew', $attribute['format']);
         $this->assertEquals(['min' => 1, 'max' => 10000], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', format: '');
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', format: '');
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -610,9 +753,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals(['min' => 1, 'max' => 10000], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', formatOptions: ['min' => 1, 'max' => 999]);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', formatOptions: ['min' => 1, 'max' => 999]);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -622,9 +765,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals(['min' => 1, 'max' => 999], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', formatOptions: []);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', formatOptions: []);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -634,9 +777,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', signed: false);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', signed: false);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -646,9 +789,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', required: true);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', required: true);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -658,9 +801,9 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', type: Database::VAR_STRING, size: Database::LENGTH_KEY, format: '');
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[4];
+        $database->updateAttribute($this->getFlowersCollection(), 'price', type: ColumnType::String, size: Database::LENGTH_KEY, format: '');
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[4];
         $this->assertEquals('string', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
         $this->assertEquals(255, $attribute['size']);
@@ -668,17 +811,17 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals(false, $attribute['array']);
         $this->assertEquals(true, $attribute['required']);
         $this->assertEquals('', $attribute['format']);
-        $this->assertEquals([], $collection->getAttribute('attributes')[4]['formatOptions']);
+        $this->assertEquals([], $collection->attributes[4]['formatOptions']);
 
         // Date attribute
-        $attribute = $collection->getAttribute('attributes')[2];
+        $attribute = $collection->attributes[2];
         $this->assertEquals('date', $attribute['key']);
         $this->assertEquals('string', $attribute['type']);
         $this->assertEquals(null, $attribute['default']);
 
-        $database->updateAttribute('flowers', 'date', type: Database::VAR_DATETIME, size: 0, filters: ['datetime']);
-        $collection = $database->getCollection('flowers');
-        $attribute = $collection->getAttribute('attributes')[2];
+        $database->updateAttribute($this->getFlowersCollection(), 'date', type: ColumnType::Datetime, size: 0, filters: ['datetime']);
+        $collection = $database->getCollection($this->getFlowersCollection());
+        $attribute = $collection->attributes[2];
         $this->assertEquals('datetime', $attribute['type']);
         $this->assertEquals(0, $attribute['size']);
         $this->assertEquals(null, $attribute['default']);
@@ -688,11 +831,11 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $doc = $database->getDocument('flowers', 'LiliPriced');
+        $doc = $database->getDocument($this->getFlowersCollection(), 'LiliPriced');
         $this->assertIsString($doc->getAttribute('price'));
         $this->assertEquals('500', $doc->getAttribute('price'));
 
-        $doc = $database->getDocument('flowers', 'flowerWithDate');
+        $doc = $database->getDocument($this->getFlowersCollection(), 'flowerWithDate');
         $this->assertEquals('2000-06-12T14:12:55.000+00:00', $doc->getAttribute('date'));
     }
 
@@ -701,14 +844,15 @@ public function testUpdateAttributeRename(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('rename_test');
+        $database->createCollection(new Collection(id: 'rename_test'));
 
-        $this->assertEquals(true, $database->createAttribute('rename_test', 'rename_me', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('rename_test', Attribute::string(key: 'rename_me', size: 128, required: true)));
 
         $doc = $database->createDocument('rename_test', new Document([
             '$permissions' => [
@@ -717,13 +861,13 @@ public function testUpdateAttributeRename(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'rename_me' => 'string'
+            'rename_me' => 'string',
         ]));
 
         $this->assertEquals('string', $doc->getAttribute('rename_me'));
 
         // Create an index to check later
-        $database->createIndex('rename_test', 'renameIndexes', Database::INDEX_KEY, ['rename_me'], [], [Database::ORDER_DESC, Database::ORDER_DESC]);
+        $database->createIndex('rename_test', Index::key(key: 'renameIndexes', attributes: ['rename_me'], orders: [Order::Desc, Order::Desc]));
 
         $database->updateAttribute(
             collection: 'rename_test',
@@ -746,37 +890,38 @@ public function testUpdateAttributeRename(): void
 
         // Check collection
         $collection = $database->getCollection('rename_test');
-        $this->assertEquals('renamed', $collection->getAttribute('attributes')[0]['key']);
-        $this->assertEquals('renamed', $collection->getAttribute('attributes')[0]['$id']);
-        $this->assertEquals('renamed', $collection->getAttribute('indexes')[0]['attributes'][0]);
+        $this->assertEquals('renamed', $collection->attributes[0]['key']);
+        $this->assertEquals('renamed', $collection->attributes[0]['$id']);
+        $this->assertEquals('renamed', $collection->indexes[0]->attributes[0]);
 
-        $supportsIdenticalIndexes = $database->getAdapter()->getSupportForIdenticalIndexes();
+        $supportsIdenticalIndexes = $database->getAdapter()->supports(Capability::IdenticalIndexes);
 
         try {
             // Check empty newKey doesn't cause issues
             $database->updateAttribute(
                 collection: 'rename_test',
                 id: 'renamed',
-                type: Database::VAR_STRING,
+                type: ColumnType::String,
             );
 
-            if (!$supportsIdenticalIndexes) {
+            if (! $supportsIdenticalIndexes) {
                 $this->fail('Expected exception when getSupportForIdenticalIndexes=false but none was thrown');
             }
         } catch (Throwable $e) {
-            if (!$supportsIdenticalIndexes) {
-                $this->assertTrue(true, 'Exception thrown as expected when getSupportForIdenticalIndexes=false');
+            if (! $supportsIdenticalIndexes) {
+                $this->assertNotSame('', $e->getMessage());
+
                 return; // Exit early if exception was expected
             } else {
-                $this->fail('Unexpected exception when getSupportForIdenticalIndexes=true: ' . $e->getMessage());
+                $this->fail('Unexpected exception when getSupportForIdenticalIndexes=true: '.$e->getMessage());
             }
         }
 
         $collection = $database->getCollection('rename_test');
 
-        $this->assertEquals('renamed', $collection->getAttribute('attributes')[0]['key']);
-        $this->assertEquals('renamed', $collection->getAttribute('attributes')[0]['$id']);
-        $this->assertEquals('renamed', $collection->getAttribute('indexes')[0]['attributes'][0]);
+        $this->assertEquals('renamed', $collection->attributes[0]['key']);
+        $this->assertEquals('renamed', $collection->attributes[0]['$id']);
+        $this->assertEquals('renamed', $collection->indexes[0]->attributes[0]);
 
         $doc = $database->getDocument('rename_test', $doc->getId());
 
@@ -784,14 +929,14 @@ public function testUpdateAttributeRename(): void
         $this->assertArrayNotHasKey('rename_me', $doc->getAttributes());
 
         // Check the metadata was correctly updated
-        $attribute = $collection->getAttribute('attributes')[0];
+        $attribute = $collection->attributes[0];
         $this->assertEquals('renamed', $attribute['key']);
         $this->assertEquals('renamed', $attribute['$id']);
 
         // Check the indexes were updated
-        $index = $collection->getAttribute('indexes')[0];
-        $this->assertEquals('renamed', $index->getAttribute('attributes')[0]);
-        $this->assertEquals(1, count($collection->getAttribute('indexes')));
+        $index = $collection->indexes[0];
+        $this->assertEquals('renamed', $index->attributes[0]);
+        $this->assertEquals(1, count($collection->indexes));
 
         // Try and create new document with new key
         $doc = $database->createDocument('rename_test', new Document([
@@ -801,7 +946,7 @@ public function testUpdateAttributeRename(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'renamed' => 'string'
+            'renamed' => 'string',
         ]));
 
         $this->assertEquals('string', $doc->getAttribute('renamed'));
@@ -815,7 +960,7 @@ public function testUpdateAttributeRename(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-                'rename_me' => 'string'
+                'rename_me' => 'string',
             ]));
             $this->fail('Succeeded creating a document with old key after renaming the attribute');
         } catch (\Exception $e) {
@@ -835,185 +980,65 @@ public function testUpdateAttributeRename(): void
         $this->assertArrayNotHasKey('renamed', $doc->getAttributes());
     }
 
-
     /**
-     * @depends testRenameAttribute
-     * @expectedException Exception
+     * Sets up the 'colors' collection with renamed attributes as testRenameAttribute would leave it.
      */
-    public function textRenameAttributeMissing(): void
+    private static bool $colorsFixtureInit = false;
+
+    protected function initColorsFixture(): void
     {
-        /** @var Database $database */
+        if (self::$colorsFixtureInit) {
+            return;
+        }
+
         $database = $this->getDatabase();
 
-        $this->expectExceptionMessage('Attribute not found');
-        $database->renameAttribute('colors', 'name2', 'name3');
+        $collection = $this->getColorsCollection();
+        $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'hex', size: 128, required: true));
+        $database->createIndex($collection, Index::key(key: 'index1', attributes: ['name'], lengths: [128], orders: [Order::Asc]));
+        $database->createDocument($collection, new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => 'black',
+            'hex' => '#000000',
+        ]));
+        $database->renameAttribute($collection, 'name', 'verbose');
+
+        self::$colorsFixtureInit = true;
     }
 
     /**
-    * @depends testRenameAttribute
-    * @expectedException Exception
-    */
-    public function testRenameAttributeExisting(): void
+     * @expectedException Exception
+     */
+    public function textRenameAttributeMissing(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->initColorsFixture();
 
-        $this->expectExceptionMessage('Attribute name already used');
-        $database->renameAttribute('colors', 'verbose', 'hex');
-    }
-
-    public function testWidthLimit(): void
-    {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getDocumentSizeLimit() === 0) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = $database->createCollection('width_limit');
-
-        $init = $database->getAdapter()->getAttributeWidth($collection);
-        $this->assertEquals(1067, $init);
-
-        $attribute = new Document([
-            '$id' => ID::custom('varchar_100'),
-            'type' => Database::VAR_STRING,
-            'size' => 100,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-        $res = $database->getAdapter()->getAttributeWidth($collection->setAttribute('attributes', [$attribute]));
-        $this->assertEquals(401, $res - $init); // 100 * 4 + 1 (length)
-
-        $attribute = new Document([
-            '$id' => ID::custom('json'),
-            'type' => Database::VAR_STRING,
-            'size' => 100,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => true,
-            'filters' => [],
-        ]);
-        $res = $database->getAdapter()->getAttributeWidth($collection->setAttribute('attributes', [$attribute]));
-        $this->assertEquals(20, $res - $init); // Pointer of Json / Longtext (mariaDB)
-
-        $attribute = new Document([
-            '$id' => ID::custom('text'),
-            'type' => Database::VAR_STRING,
-            'size' => 20000,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-        $res = $database->getAdapter()->getAttributeWidth($collection->setAttribute('attributes', [$attribute]));
-        $this->assertEquals(20, $res - $init);
-
-        $attribute = new Document([
-            '$id' => ID::custom('bigint'),
-            'type' => Database::VAR_INTEGER,
-            'size' => 8,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-        $res = $database->getAdapter()->getAttributeWidth($collection->setAttribute('attributes', [$attribute]));
-        $this->assertEquals(8, $res - $init);
-
-        $attribute = new Document([
-            '$id' => ID::custom('date'),
-            'type' => Database::VAR_DATETIME,
-            'size' => 8,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-        $res = $database->getAdapter()->getAttributeWidth($collection->setAttribute('attributes', [$attribute]));
-        $this->assertEquals(7, $res - $init);
+        $this->expectExceptionMessage('Attribute not found');
+        $database->renameAttribute($this->getColorsCollection(), 'name2', 'name3');
     }
 
-    public function testExceptionAttributeLimit(): void
+    /**
+     * @expectedException Exception
+     */
+    public function testRenameAttributeExisting(): void
     {
+        $this->initColorsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getLimitForAttributes() === 0) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $limit = $database->getAdapter()->getLimitForAttributes() - $database->getAdapter()->getCountOfDefaultAttributes();
-
-        $attributes = [];
-
-        for ($i = 0; $i <= $limit; $i++) {
-            $attributes[] = new Document([
-                '$id' => ID::custom("attr_{$i}"),
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false,
-                'default' => null,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]);
-        }
-
-        try {
-            $database->createCollection('attributes_limit', $attributes);
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-            $this->assertEquals('Attribute limit of 1017 exceeded. Cannot create collection.', $e->getMessage());
-        }
-
-        /**
-         * Remove last attribute
-         */
-
-        array_pop($attributes);
-
-        $collection = $database->createCollection('attributes_limit', $attributes);
-
-        $attribute = new Document([
-            '$id' => ID::custom('breaking'),
-            'type' => Database::VAR_STRING,
-            'size' => 100,
-            'required' => true,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        try {
-            $database->checkAttribute($collection, $attribute);
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-            $this->assertStringContainsString('Column limit reached. Cannot create new attribute.', $e->getMessage());
-            $this->assertStringContainsString('Remove some attributes to free up space.', $e->getMessage());
-        }
-
-        try {
-            $database->createAttribute($collection->getId(), 'breaking', Database::VAR_STRING, 100, true);
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-            $this->assertStringContainsString('Column limit reached. Cannot create new attribute.', $e->getMessage());
-            $this->assertStringContainsString('Remove some attributes to free up space.', $e->getMessage());
-        }
+        $this->expectExceptionMessage('Attribute name already used');
+        $database->renameAttribute($this->getColorsCollection(), 'verbose', 'hex');
     }
 
     public function testExceptionWidthLimit(): void
@@ -1023,35 +1048,18 @@ public function testExceptionWidthLimit(): void
 
         if ($database->getAdapter()->getDocumentSizeLimit() === 0) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $attributes = [];
 
-        $attributes[] = new Document([
-            '$id' => ID::custom('varchar_16000'),
-            'type' => Database::VAR_STRING,
-            'size' => 16000,
-            'required' => true,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
+        $attributes[] = Attribute::string(key: 'varchar_16000', size: 16000, required: true);
 
-        $attributes[] = new Document([
-            '$id' => ID::custom('varchar_200'),
-            'type' => Database::VAR_STRING,
-            'size' => 200,
-            'required' => true,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
+        $attributes[] = Attribute::string(key: 'varchar_200', size: 200, required: true);
 
         try {
-            $database->createCollection("attributes_row_size", $attributes);
+            $database->createCollection(new Collection(id: 'attributes_row_size', attributes: $attributes));
             $this->fail('Failed to throw exception');
         } catch (\Throwable $e) {
             $this->assertInstanceOf(LimitException::class, $e);
@@ -1061,21 +1069,11 @@ public function testExceptionWidthLimit(): void
         /**
          * Remove last attribute
          */
-
         array_pop($attributes);
 
-        $collection = $database->createCollection("attributes_row_size", $attributes);
-
-        $attribute = new Document([
-            '$id' => ID::custom('breaking'),
-            'type' => Database::VAR_STRING,
-            'size' => 200,
-            'required' => true,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
+        $collection = $database->createCollection(new Collection(id: 'attributes_row_size', attributes: $attributes));
+
+        $attribute = Attribute::string(key: 'breaking', size: 200, required: true);
 
         try {
             $database->checkAttribute($collection, $attribute);
@@ -1088,7 +1086,7 @@ public function testExceptionWidthLimit(): void
         }
 
         try {
-            $database->createAttribute($collection->getId(), 'breaking', Database::VAR_STRING, 200, true);
+            $database->createAttribute($collection->getId(), Attribute::string(key: 'breaking', size: 200, required: true));
             $this->fail('Failed to throw exception');
         } catch (\Throwable $e) {
             $this->assertInstanceOf(LimitException::class, $e);
@@ -1103,14 +1101,15 @@ public function testUpdateAttributeSize(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributeResizing()) {
+        if (! $database->getAdapter()->supports(Capability::AttributeResizing)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('resize_test');
+        $database->createCollection(new Collection(id: 'resize_test'));
 
-        $this->assertEquals(true, $database->createAttribute('resize_test', 'resize_me', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('resize_test', Attribute::string(key: 'resize_me', size: 128, required: true)));
         $document = $database->createDocument('resize_test', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
@@ -1119,7 +1118,7 @@ public function testUpdateAttributeSize(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'resize_me' => $this->createRandomString(128)
+            'resize_me' => $this->createRandomString(128),
         ]));
 
         // Go up in size
@@ -1135,21 +1134,21 @@ public function testUpdateAttributeSize(): void
 
         // Test going down in size with data that is too big (Expect Failure)
         try {
-            $database->updateAttribute('resize_test', 'resize_me', Database::VAR_STRING, 128, true);
+            $database->updateAttribute('resize_test', 'resize_me', ColumnType::String->value, 128, true);
             $this->fail('Succeeded updating attribute size to smaller size with data that is too big');
         } catch (TruncateException $e) {
         }
 
         // Test going down in size when data isn't too big.
         $database->updateDocument('resize_test', $document->getId(), $document->setAttribute('resize_me', $this->createRandomString(128)));
-        $database->updateAttribute('resize_test', 'resize_me', Database::VAR_STRING, 128, true);
+        $database->updateAttribute('resize_test', 'resize_me', ColumnType::String->value, 128, true);
 
         // VARCHAR -> VARCHAR Truncation Test
-        $database->updateAttribute('resize_test', 'resize_me', Database::VAR_STRING, 1000, true);
+        $database->updateAttribute('resize_test', 'resize_me', ColumnType::String->value, 1000, true);
         $database->updateDocument('resize_test', $document->getId(), $document->setAttribute('resize_me', $this->createRandomString(1000)));
 
         try {
-            $database->updateAttribute('resize_test', 'resize_me', Database::VAR_STRING, 128, true);
+            $database->updateAttribute('resize_test', 'resize_me', ColumnType::String->value, 128, true);
             $this->fail('Succeeded updating attribute size to smaller size with data that is too big');
         } catch (TruncateException $e) {
         }
@@ -1157,16 +1156,16 @@ public function testUpdateAttributeSize(): void
         if ($database->getAdapter()->getMaxIndexLength() > 0) {
             $length = intval($database->getAdapter()->getMaxIndexLength() / 2);
 
-            $this->assertEquals(true, $database->createAttribute('resize_test', 'attr1', Database::VAR_STRING, $length, true));
-            $this->assertEquals(true, $database->createAttribute('resize_test', 'attr2', Database::VAR_STRING, $length, true));
+            $this->assertEquals(true, $database->createAttribute('resize_test', Attribute::string(key: 'attr1', size: $length, required: true)));
+            $this->assertEquals(true, $database->createAttribute('resize_test', Attribute::string(key: 'attr2', size: $length, required: true)));
 
             /**
              * No index length provided, we are able to validate
              */
-            $database->createIndex('resize_test', 'index1', Database::INDEX_KEY, ['attr1', 'attr2']);
+            $database->createIndex('resize_test', Index::key(key: 'index1', attributes: ['attr1', 'attr2']));
 
             try {
-                $database->updateAttribute('resize_test', 'attr1', Database::VAR_STRING, 5000);
+                $database->updateAttribute('resize_test', 'attr1', ColumnType::String->value, 5000);
                 $this->fail('Failed to throw exception');
             } catch (Throwable $e) {
                 $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
@@ -1178,15 +1177,15 @@ public function testUpdateAttributeSize(): void
              * Index lengths are provided, We are able to validate
              * Index $length === attr1, $length === attr2, so $length is removed, so we are able to validate
              */
-            $database->createIndex('resize_test', 'index1', Database::INDEX_KEY, ['attr1', 'attr2'], [$length, $length]);
+            $database->createIndex('resize_test', Index::key(key: 'index1', attributes: ['attr1', 'attr2'], lengths: [$length, $length]));
 
             $collection = $database->getCollection('resize_test');
-            $indexes = $collection->getAttribute('indexes', []);
-            $this->assertEquals(null, $indexes[0]['lengths'][0]);
-            $this->assertEquals(null, $indexes[0]['lengths'][1]);
+            $indexes = $collection->indexes;
+            $this->assertEquals(null, $indexes[0]->lengths[0]);
+            $this->assertEquals(null, $indexes[0]->lengths[1]);
 
             try {
-                $database->updateAttribute('resize_test', 'attr1', Database::VAR_STRING, 5000);
+                $database->updateAttribute('resize_test', 'attr1', ColumnType::String->value, 5000);
                 $this->fail('Failed to throw exception');
             } catch (Throwable $e) {
                 $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
@@ -1198,14 +1197,14 @@ public function testUpdateAttributeSize(): void
              * Index lengths are provided
              * We are able to increase size because index length remains 50
              */
-            $database->createIndex('resize_test', 'index1', Database::INDEX_KEY, ['attr1', 'attr2'], [50, 50]);
+            $database->createIndex('resize_test', Index::key(key: 'index1', attributes: ['attr1', 'attr2'], lengths: [50, 50]));
 
             $collection = $database->getCollection('resize_test');
-            $indexes = $collection->getAttribute('indexes', []);
-            $this->assertEquals(50, $indexes[0]['lengths'][0]);
-            $this->assertEquals(50, $indexes[0]['lengths'][1]);
+            $indexes = $collection->indexes;
+            $this->assertEquals(50, $indexes[0]->lengths[0]);
+            $this->assertEquals(50, $indexes[0]->lengths[1]);
 
-            $database->updateAttribute('resize_test', 'attr1', Database::VAR_STRING, 5000);
+            $database->updateAttribute('resize_test', 'attr1', ColumnType::String->value, 5000);
         }
     }
 
@@ -1217,27 +1216,44 @@ public function testEncryptAttributes(): void
         // Add custom encrypt filter
         $database->addFilter(
             'encrypt',
-            function (mixed $value) {
+            function (mixed $value): string {
+                if (! \is_scalar($value) && $value !== null) {
+                    throw new \InvalidArgumentException('Encrypted filter input must be scalar or null');
+                }
+
                 return json_encode([
-                    'data' => base64_encode($value),
+                    'data' => base64_encode((string) $value),
                     'method' => 'base64',
                     'version' => 'v1',
-                ]);
+                ]) ?: throw new \RuntimeException('Failed to encode encrypted filter input');
             },
-            function (mixed $value) {
+            function (mixed $value): ?string {
                 if (is_null($value)) {
-                    return;
+                    return null;
+                }
+                if (! \is_string($value)) {
+                    throw new \InvalidArgumentException('Encrypted filter value must be a string');
                 }
+
                 $value = json_decode($value, true);
-                return base64_decode($value['data']);
+                if (! \is_array($value) || ! \is_string($value['data'] ?? null)) {
+                    throw new \InvalidArgumentException('Encrypted filter payload is invalid');
+                }
+
+                $decoded = base64_decode($value['data'], true);
+                if ($decoded === false) {
+                    throw new \InvalidArgumentException('Encrypted filter payload is not valid base64');
+                }
+
+                return $decoded;
             }
         );
 
-        $col = $database->createCollection(__FUNCTION__);
-        $this->assertNotNull($col->getId());
+        $col = $database->createCollection(new Collection(id: __FUNCTION__));
+        $this->assertNotSame('', $col->getId());
 
-        $database->createAttribute($col->getId(), 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute($col->getId(), 'encrypt', Database::VAR_STRING, 128, true, filters: ['encrypt']);
+        $database->createAttribute($col->getId(), Attribute::string(key: 'title', required: true));
+        $database->createAttribute($col->getId(), Attribute::string(key: 'encrypt', size: 128, required: true, filters: ['encrypt']));
 
         $database->createDocument($col->getId(), new Document([
             'title' => 'Sample Title',
@@ -1282,9 +1298,9 @@ function (mixed $value) use (&$calls) {
             }
         );
 
-        $database->createCollection('filterSelect');
-        $database->createAttribute('filterSelect', 'plain', Database::VAR_STRING, 128, false);
-        $database->createAttribute('filterSelect', 'kids', Database::VAR_STRING, 128, false, filters: ['subQueryProbe']);
+        $database->createCollection(new Collection(id: 'filterSelect'));
+        $database->createAttribute('filterSelect', Attribute::string(key: 'plain', size: 128));
+        $database->createAttribute('filterSelect', Attribute::string(key: 'kids', size: 128, filters: ['subQueryProbe']));
 
         $database->createDocument('filterSelect', new Document([
             '$id' => 'doc1',
@@ -1337,7 +1353,7 @@ public function updateStringAttributeSize(int $size, Document $document): Docume
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->updateAttribute('resize_test', 'resize_me', Database::VAR_STRING, $size, true);
+        $database->updateAttribute('resize_test', 'resize_me', ColumnType::String->value, $size, true);
 
         $document = $document->setAttribute('resize_me', $this->createRandomString($size));
 
@@ -1345,42 +1361,13 @@ public function updateStringAttributeSize(int $size, Document $document): Docume
         $checkDoc = $database->getDocument('resize_test', $document->getId());
 
         $this->assertEquals($document->getAttribute('resize_me'), $checkDoc->getAttribute('resize_me'));
-        $this->assertEquals($size, strlen($checkDoc->getAttribute('resize_me')));
+        $resized = $checkDoc->getAttribute('resize_me');
+        $this->assertIsString($resized);
+        $this->assertEquals($size, strlen($resized));
 
         return $checkDoc;
     }
 
-    /**
-     * @depends testAttributeCaseInsensitivity
-     */
-    public function testIndexCaseInsensitivity(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $this->assertEquals(true, $database->createIndex('attributes', 'key_caseSensitive', Database::INDEX_KEY, ['caseSensitive'], [128]));
-
-        try {
-            $this->assertEquals(true, $database->createIndex('attributes', 'key_CaseSensitive', Database::INDEX_KEY, ['caseSensitive'], [128]));
-        } catch (Throwable $e) {
-            self::assertTrue($e instanceof DuplicateException);
-        }
-    }
-
-    /**
-     * Ensure the collection is removed after use
-     *
-     * @depends testIndexCaseInsensitivity
-     */
-    public function testCleanupAttributeTests(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->deleteCollection('attributes');
-        $this->assertEquals(1, 1);
-    }
-
     /**
      * @throws AuthorizationException
      * @throws DuplicateException
@@ -1398,89 +1385,31 @@ public function testArrayAttribute(): void
         $collection = 'json';
         $permissions = [Permission::read(Role::any())];
 
-        $database->createCollection($collection, permissions: [
+        $database->createCollection(new Collection(id: $collection, permissions: [
             Permission::create(Role::any()),
-        ]);
+        ]));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'booleans',
-            Database::VAR_BOOLEAN,
-            size: 0,
-            required: true,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::boolean(key: 'booleans', required: true, array: true)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'names',
-            Database::VAR_STRING,
-            size: 255, // Does this mean each Element max is 255? We need to check this on Structure validation?
-            required: false,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'names', array: true)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'cards',
-            Database::VAR_STRING,
-            size: 5000,
-            required: false,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'cards', size: 5000, array: true)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'numbers',
-            Database::VAR_INTEGER,
-            size: 0,
-            required: false,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'numbers', array: true)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'age',
-            Database::VAR_INTEGER,
-            size: 0,
-            required: false,
-            signed: false
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'age', signed: false)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'tv_show',
-            Database::VAR_STRING,
-            size: $database->getAdapter()->getMaxIndexLength() - 68,
-            required: false,
-            signed: false,
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'tv_show', size: $database->getAdapter()->getMaxIndexLength() - 68, signed: false)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'short',
-            Database::VAR_STRING,
-            size: 5,
-            required: false,
-            signed: false,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'short', size: 5, signed: false, array: true)));
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'pref',
-            Database::VAR_STRING,
-            size: 16384,
-            required: false,
-            signed: false,
-            filters: ['json'],
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'pref', size: 16384, signed: false, filters: ['json'])));
 
         try {
             $database->createDocument($collection, new Document([]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertEquals('Invalid document structure: Missing required attribute "booleans"', $e->getMessage());
             }
         }
@@ -1488,7 +1417,7 @@ public function testArrayAttribute(): void
         $database->updateAttribute($collection, 'booleans', required: false);
 
         $doc = $database->getCollection($collection);
-        $attribute = $doc->getAttribute('attributes')[0];
+        $attribute = $doc->attributes[0];
         $this->assertEquals('boolean', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -1502,7 +1431,7 @@ public function testArrayAttribute(): void
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertEquals('Invalid document structure: Attribute "short[\'0\']" has invalid type. Value must be a valid string and no longer than 5 chars', $e->getMessage());
             }
         }
@@ -1513,7 +1442,7 @@ public function testArrayAttribute(): void
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertEquals('Invalid document structure: Attribute "names[\'1\']" has invalid type. Value must be a valid string and no longer than 255 chars', $e->getMessage());
             }
         }
@@ -1524,7 +1453,7 @@ public function testArrayAttribute(): void
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertEquals('Invalid document structure: Attribute "age" has invalid type. Value must be a valid unsigned 32-bit integer between 0 and 4,294,967,295', $e->getMessage());
             }
         }
@@ -1535,7 +1464,7 @@ public function testArrayAttribute(): void
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertEquals('Invalid document structure: Attribute "age" has invalid type. Value must be a valid unsigned 32-bit integer between 0 and 4,294,967,295', $e->getMessage());
             }
         }
@@ -1558,18 +1487,18 @@ public function testArrayAttribute(): void
 
         $document = $database->getDocument($collection, 'id1');
 
-        $this->assertEquals(false, $document->getAttribute('booleans')[0]);
-        $this->assertEquals('Antony', $document->getAttribute('names')[1]);
-        $this->assertEquals(100, $document->getAttribute('numbers')[1]);
+        $this->assertEquals(false, $document->getArray('booleans')[0]);
+        $this->assertEquals('Antony', $document->getArray('names')[1]);
+        $this->assertEquals(100, $document->getArray('numbers')[1]);
 
-        if ($database->getAdapter()->getSupportForIndexArray()) {
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
             /**
              * Functional index dependency cannot be dropped or rename
              */
-            $database->createIndex($collection, 'idx_cards', Database::INDEX_KEY, ['cards'], [100]);
+            $database->createIndex($collection, Index::key(key: 'idx_cards', attributes: ['cards'], lengths: [100]));
         }
 
-        if ($database->getAdapter()->getSupportForCastIndexArray()) {
+        if ($database->getAdapter()->supports(Capability::CastIndexArray)) {
             /**
              * Delete attribute
              */
@@ -1596,7 +1525,7 @@ public function testArrayAttribute(): void
              * Update attribute
              */
             try {
-                $database->updateAttribute($collection, id:'cards', newKey: 'cards_new');
+                $database->updateAttribute($collection, id: 'cards', newKey: 'cards_new');
                 $this->fail('Failed to throw exception');
             } catch (Throwable $e) {
                 $this->assertInstanceOf(DependencyException::class, $e);
@@ -1608,14 +1537,14 @@ public function testArrayAttribute(): void
             $this->assertTrue($database->deleteAttribute($collection, 'cards_new'));
         }
 
-        if ($database->getAdapter()->getSupportForIndexArray()) {
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
             try {
-                $database->createIndex($collection, 'indx', Database::INDEX_FULLTEXT, ['names']);
-                if ($database->getAdapter()->getSupportForAttributes()) {
+                $database->createIndex($collection, Index::fullText(key: 'indx', attributes: ['names']));
+                if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                     $this->fail('Failed to throw exception');
                 }
             } catch (Throwable $e) {
-                if ($database->getAdapter()->getSupportForFulltextIndex()) {
+                if ($database->getAdapter()->supports(Capability::Fulltext)) {
                     $this->assertEquals('"Fulltext" index is forbidden on array attributes', $e->getMessage());
                 } else {
                     $this->assertEquals('Fulltext index is not supported', $e->getMessage());
@@ -1623,12 +1552,12 @@ public function testArrayAttribute(): void
             }
 
             try {
-                $database->createIndex($collection, 'indx', Database::INDEX_KEY, ['numbers', 'names'], [100,100]);
-                if ($database->getAdapter()->getSupportForAttributes()) {
+                $database->createIndex($collection, Index::key(key: 'indx', attributes: ['numbers', 'names'], lengths: [100, 100]));
+                if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                     $this->fail('Failed to throw exception');
                 }
             } catch (Throwable $e) {
-                if ($database->getAdapter()->getSupportForAttributes()) {
+                if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                     $this->assertEquals('An index may only contain one array attribute', $e->getMessage());
                 } else {
                     $this->assertEquals('Index already exists', $e->getMessage());
@@ -1636,44 +1565,37 @@ public function testArrayAttribute(): void
             }
         }
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'long_size',
-            Database::VAR_STRING,
-            size: 2000,
-            required: false,
-            array: true
-        ));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'long_size', size: 2000, array: true)));
 
-        if ($database->getAdapter()->getSupportForIndexArray()) {
-            if ($database->getAdapter()->getSupportForAttributes() && $database->getAdapter()->getMaxIndexLength() > 0) {
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes) && $database->getAdapter()->getMaxIndexLength() > 0) {
                 // If getMaxIndexLength() > 0 We clear length for array attributes
-                $database->createIndex($collection, 'indx1', Database::INDEX_KEY, ['long_size'], [], []);
+                $database->createIndex($collection, Index::key(key: 'indx1', attributes: ['long_size']));
                 $database->deleteIndex($collection, 'indx1');
-                $database->createIndex($collection, 'indx2', Database::INDEX_KEY, ['long_size'], [1000], []);
+                $database->createIndex($collection, Index::key(key: 'indx2', attributes: ['long_size'], lengths: [1000]));
 
                 try {
-                    $database->createIndex($collection, 'indx_numbers', Database::INDEX_KEY, ['tv_show', 'numbers'], [], []); // [700, 255]
+                    $database->createIndex($collection, Index::key(key: 'indx_numbers', attributes: ['tv_show', 'numbers'])); // [700, 255]
                     $this->fail('Failed to throw exception');
                 } catch (Throwable $e) {
-                    $this->assertEquals('Index length is longer than the maximum: ' . $database->getAdapter()->getMaxIndexLength(), $e->getMessage());
+                    $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
                 }
             }
 
             try {
-                if ($database->getAdapter()->getSupportForAttributes()) {
-                    $database->createIndex($collection, 'indx4', Database::INDEX_KEY, ['age', 'names'], [10, 255], []);
+                if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+                    $database->createIndex($collection, Index::key(key: 'indx4', attributes: ['age', 'names'], lengths: [10, 255]));
                     $this->fail('Failed to throw exception');
                 }
             } catch (Throwable $e) {
                 $this->assertEquals('Cannot set a length on "integer" attributes', $e->getMessage());
             }
 
-            $this->assertTrue($database->createIndex($collection, 'indx6', Database::INDEX_KEY, ['age', 'names'], [null, 999], []));
-            $this->assertTrue($database->createIndex($collection, 'indx7', Database::INDEX_KEY, ['age', 'booleans'], [0, 999], []));
+            $this->assertTrue($database->createIndex($collection, Index::key(key: 'indx6', attributes: ['age', 'names'], lengths: [null, 999])));
+            $this->assertTrue($database->createIndex($collection, Index::key(key: 'indx7', attributes: ['age', 'booleans'], lengths: [0, 999])));
         }
 
-        if ($this->getDatabase()->getAdapter()->getSupportForQueryContains()) {
+        if ($this->getDatabase()->getAdapter()->supports(Capability::QueryContains)) {
             try {
                 $database->find($collection, [
                     Query::equal('names', ['Joe']),
@@ -1685,7 +1607,7 @@ public function testArrayAttribute(): void
 
             try {
                 $database->find($collection, [
-                    Query::contains('age', [10])
+                    Query::contains('age', [10]),
                 ]);
                 $this->fail('Failed to throw exception');
             } catch (Throwable $e) {
@@ -1693,66 +1615,66 @@ public function testArrayAttribute(): void
             }
 
             $documents = $database->find($collection, [
-                Query::isNull('long_size')
+                Query::isNull('long_size'),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::contains('tv_show', ['love'])
+                Query::contains('tv_show', ['love']),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::contains('names', ['Jake', 'Joe'])
+                Query::contains('names', ['Jake', 'Joe']),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::contains('numbers', [-1, 0, 999])
+                Query::contains('numbers', [-1, 0, 999]),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::contains('booleans', [false, true])
+                Query::contains('booleans', [false, true]),
             ]);
             $this->assertCount(1, $documents);
 
             // Regular like query on primitive json string data
             $documents = $database->find($collection, [
-                Query::contains('pref', ['Joe'])
+                Query::contains('pref', ['Joe']),
             ]);
             $this->assertCount(1, $documents);
 
             // containsAny tests — should behave identically to contains
 
             $documents = $database->find($collection, [
-                Query::containsAny('tv_show', ['love'])
+                Query::containsAny('tv_show', ['love']),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::containsAny('names', ['Jake', 'Joe'])
+                Query::containsAny('names', ['Jake', 'Joe']),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::containsAny('numbers', [-1, 0, 999])
+                Query::containsAny('numbers', [-1, 0, 999]),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::containsAny('booleans', [false, true])
+                Query::containsAny('booleans', [false, true]),
             ]);
             $this->assertCount(1, $documents);
 
             $documents = $database->find($collection, [
-                Query::containsAny('pref', ['Joe'])
+                Query::containsAny('pref', ['Joe']),
             ]);
             $this->assertCount(1, $documents);
 
             // containsAny with no matching values
             $documents = $database->find($collection, [
-                Query::containsAny('names', ['Jake', 'Unknown'])
+                Query::containsAny('names', ['Jake', 'Unknown']),
             ]);
             $this->assertCount(0, $documents);
 
@@ -1760,37 +1682,37 @@ public function testArrayAttribute(): void
 
             // All values present in names array
             $documents = $database->find($collection, [
-                Query::containsAll('names', ['Joe', 'Antony'])
+                Query::containsAll('names', ['Joe', 'Antony']),
             ]);
             $this->assertCount(1, $documents);
 
             // One value missing from names array
             $documents = $database->find($collection, [
-                Query::containsAll('names', ['Joe', 'Jake'])
+                Query::containsAll('names', ['Joe', 'Jake']),
             ]);
             $this->assertCount(0, $documents);
 
             // All values present in numbers array
             $documents = $database->find($collection, [
-                Query::containsAll('numbers', [0, 100, -1])
+                Query::containsAll('numbers', [0, 100, -1]),
             ]);
             $this->assertCount(1, $documents);
 
             // One value missing from numbers array
             $documents = $database->find($collection, [
-                Query::containsAll('numbers', [0, 999])
+                Query::containsAll('numbers', [0, 999]),
             ]);
             $this->assertCount(0, $documents);
 
             // Single value containsAll — should match
             $documents = $database->find($collection, [
-                Query::containsAll('booleans', [false])
+                Query::containsAll('booleans', [false]),
             ]);
             $this->assertCount(1, $documents);
 
             // Boolean value not present
             $documents = $database->find($collection, [
-                Query::containsAll('booleans', [true])
+                Query::containsAll('booleans', [true]),
             ]);
             $this->assertCount(0, $documents);
         }
@@ -1801,21 +1723,21 @@ public function testCreateDatetime(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('datetime');
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->assertEquals(true, $database->createAttribute('datetime', 'date', Database::VAR_DATETIME, 0, true, null, true, false, null, [], ['datetime']));
-            $this->assertEquals(true, $database->createAttribute('datetime', 'date2', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']));
+        $database->createCollection(new Collection(id: 'datetime'));
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute('datetime', Attribute::datetime(key: 'date', required: true, filters: ['datetime'])));
+            $this->assertEquals(true, $database->createAttribute('datetime', Attribute::datetime(key: 'date2', filters: ['datetime'])));
         }
 
         try {
             $database->createDocument('datetime', new Document([
                 'date' => ['2020-01-01'], // array
             ]));
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->fail('Failed to throw exception');
             }
         } catch (Exception $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertInstanceOf(StructureException::class, $e);
             }
         }
@@ -1831,10 +1753,14 @@ public function testCreateDatetime(): void
             'date' => DateTime::now(),
         ]));
 
-        $this->assertEquals(29, strlen($doc->getCreatedAt()));
-        $this->assertEquals(29, strlen($doc->getUpdatedAt()));
-        $this->assertEquals('+00:00', substr($doc->getCreatedAt(), -6));
-        $this->assertEquals('+00:00', substr($doc->getUpdatedAt(), -6));
+        $createdAt = $doc->getCreatedAt();
+        $updatedAt = $doc->getUpdatedAt();
+        $this->assertNotNull($createdAt);
+        $this->assertNotNull($updatedAt);
+        $this->assertEquals(29, strlen($createdAt));
+        $this->assertEquals(29, strlen($updatedAt));
+        $this->assertEquals('+00:00', substr($createdAt, -6));
+        $this->assertEquals('+00:00', substr($updatedAt, -6));
         $this->assertGreaterThan('2020-08-16T19:30:08.363+00:00', $doc->getCreatedAt());
         $this->assertGreaterThan('2020-08-16T19:30:08.363+00:00', $doc->getUpdatedAt());
 
@@ -1861,26 +1787,26 @@ public function testCreateDatetime(): void
         try {
             $database->createDocument('datetime', new Document([
                 '$id' => 'datenew1',
-                'date' => "1975-12-06 00:00:61", // 61 seconds is invalid,
+                'date' => '1975-12-06 00:00:61', // 61 seconds is invalid,
             ]));
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->fail('Failed to throw exception');
             }
         } catch (Exception $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertInstanceOf(StructureException::class, $e);
             }
         }
 
         try {
             $database->createDocument('datetime', new Document([
-                'date' => '+055769-02-14T17:56:18.000Z'
+                'date' => '+055769-02-14T17:56:18.000Z',
             ]));
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->fail('Failed to throw exception');
             }
         } catch (Exception $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertInstanceOf(StructureException::class, $e);
             }
         }
@@ -1888,13 +1814,13 @@ public function testCreateDatetime(): void
         $invalidDates = [
             '+055769-02-14T17:56:18.000Z1',
             '1975-12-06 00:00:61',
-            '16/01/2024 12:00:00AM'
+            '16/01/2024 12:00:00AM',
         ];
 
         foreach ($invalidDates as $date) {
             try {
                 $database->find('datetime', [
-                    Query::equal('$createdAt', [$date])
+                    Query::equal('$createdAt', [$date]),
                 ]);
                 $this->fail('Failed to throw exception');
             } catch (Throwable $e) {
@@ -1904,9 +1830,9 @@ public function testCreateDatetime(): void
 
             try {
                 $database->find('datetime', [
-                    Query::equal('date', [$date])
+                    Query::equal('date', [$date]),
                 ]);
-                if ($database->getAdapter()->getSupportForAttributes()) {
+                if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                     $this->fail('Failed to throw exception');
                 }
             } catch (Throwable $e) {
@@ -1916,18 +1842,18 @@ public function testCreateDatetime(): void
         }
 
         $validDates = [
-            '2024-12-2509:00:21.891119',
-            'Tue Dec 31 2024',
+            '2024-12-25 09:00:21.891119',
+            '2024-12-31 00:00:00.000000',
         ];
 
         foreach ($validDates as $date) {
             $docs = $database->find('datetime', [
-                Query::equal('$createdAt', [$date])
+                Query::equal('$createdAt', [$date]),
             ]);
             $this->assertCount(0, $docs);
 
             $docs = $database->find('datetime', [
-                Query::equal('date', [$date])
+                Query::equal('date', [$date]),
             ]);
             $this->assertCount(0, $docs);
 
@@ -1937,7 +1863,7 @@ public function testCreateDatetime(): void
             $docs = $database->find('datetime', [
                 Query::or([
                     Query::equal('$createdAt', [$date]),
-                    Query::equal('date', [$date])
+                    Query::equal('date', [$date]),
                 ]),
             ]);
             $this->assertCount(0, $docs);
@@ -1949,384 +1875,52 @@ public function testCreateDatetimeAddingAutoFilter(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('datetime_auto_filter');
+        $database->createCollection(new Collection(id: 'datetime_auto_filter'));
 
         $this->expectException(Exception::class);
-        $database->createAttribute('datetime_auto', 'date_auto', Database::VAR_DATETIME, 0, false, filters:['json']);
+        $database->createAttribute('datetime_auto', Attribute::datetime(key: 'date_auto', filters: ['json']));
         $collection = $database->getCollection('datetime_auto_filter');
-        $attribute = $collection->getAttribute('attributes')[0];
-        $this->assertEquals([Database::VAR_DATETIME,'json'], $attribute['filters']);
-        $database->updateAttribute('datetime_auto', 'date_auto', Database::VAR_DATETIME, 0, false, filters:[]);
+        $attribute = $collection->attributes[0];
+        $this->assertEquals([ColumnType::Datetime->value, 'json'], $attribute['filters']);
+        $database->updateAttribute('datetime_auto', 'date_auto', ColumnType::Datetime->value, 0, false, filters: []);
         $collection = $database->getCollection('datetime_auto_filter');
-        $attribute = $collection->getAttribute('attributes')[0];
-        $this->assertEquals([Database::VAR_DATETIME,'json'], $attribute['filters']);
+        $attribute = $collection->attributes[0];
+        $this->assertEquals([ColumnType::Datetime->value, 'json'], $attribute['filters']);
         $database->deleteCollection('datetime_auto_filter');
     }
-    /**
-     * @depends testCreateDeleteAttribute
-     * @expectedException Exception
-     */
-    public function testUnknownFormat(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $this->expectException(\Exception::class);
-        $this->assertEquals(false, $database->createAttribute('attributes', 'bad_format', Database::VAR_STRING, 256, true, null, true, false, 'url'));
-    }
-
-
-    // Bulk attribute creation tests
-    public function testCreateAttributesEmpty(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        try {
-            $database->createAttributes(__FUNCTION__, []);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesMissingId(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            'type' => Database::VAR_STRING,
-            'size' => 10,
-            'required' => false
-        ]];
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesMissingType(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'size' => 10,
-            'required' => false
-        ]];
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesMissingSize(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_STRING,
-            'required' => false
-        ]];
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesMissingRequired(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_STRING,
-            'size' => 10
-        ]];
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesDuplicateMetadata(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'dup', Database::VAR_STRING, 10, false);
-
-        $attributes = [[
-            '$id' => 'dup',
-            'type' => Database::VAR_STRING,
-            'size' => 10,
-            'required' => false
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DuplicateException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesInvalidFilter(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'date',
-            'type' => Database::VAR_DATETIME,
-            'size' => 0,
-            'required' => false,
-            'filters' => []
-        ]];
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesInvalidFormat(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_STRING,
-            'size' => 10,
-            'required' => false,
-            'format' => 'nonexistent'
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesDefaultOnRequired(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_STRING,
-            'size' => 10,
-            'required' => true,
-            'default' => 'bar'
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesUnknownType(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => 'unknown',
-            'size' => 0,
-            'required' => false
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesStringSizeLimit(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $max = $database->getAdapter()->getLimitForString();
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_STRING,
-            'size' => $max + 1,
-            'required' => false
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
-    public function testCreateAttributesIntegerSizeLimit(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $limit = $database->getAdapter()->getLimitForInt() / 2;
-
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_INTEGER,
-            'size' => (int)$limit + 1,
-            'required' => false
-        ]];
-
-        try {
-            $database->createAttributes(__FUNCTION__, $attributes);
-            $this->fail('Expected DatabaseException not thrown');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-        }
-    }
-
 
     public function testCreateAttributesBigIntIgnoresSizeMetadata(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::BatchCreateAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionName = 'bigint_ignores_size_limit';
-        $database->createCollection($collectionName);
+        $database->createCollection(new Collection(id: $collectionName));
 
-        $attributes = [[
-            '$id' => 'foo',
-            'type' => Database::VAR_BIGINT,
-            'size' => 9999,
-            'required' => false
-        ]];
+        $attributes = [Attribute::bigInteger(key: 'foo', size: 9999)];
 
         $result = $database->createAttributes($collectionName, $attributes);
         $this->assertTrue($result);
 
         $collection = $database->getCollection($collectionName);
-        $attrs = $collection->getAttribute('attributes');
+        $attrs = $collection->attributes;
         $this->assertCount(1, $attrs);
-        $this->assertEquals('foo', $attrs[0]['$id']);
-        $this->assertEquals(0, $attrs[0]['size']);
+        $attribute = $attrs[0] ?? null;
+        $this->assertInstanceOf(Document::class, $attribute);
+        $this->assertSame('foo', $attribute->getId());
+        $this->assertSame(0, $attribute->getAttribute('size'));
 
-        $database->updateAttribute($collectionName, 'foo', size: 1);
+        $database->updateAttribute($collectionName, 'foo', type: ColumnType::BigInteger, size: 1);
         $collection = $database->getCollection($collectionName);
-        $attrs = $collection->getAttribute('attributes');
-        $this->assertEquals(0, $attrs[0]['size']);
+        $attrs = $collection->attributes;
+        $attribute = $attrs[0] ?? null;
+        $this->assertInstanceOf(Document::class, $attribute);
+        $this->assertSame(0, $attribute->getAttribute('size'));
     }
 
     public function testCreateAttributesBigIntValidationSignedUnsignedAndMetadata(): void
@@ -2335,55 +1929,49 @@ public function testCreateAttributesBigIntValidationSignedUnsignedAndMetadata():
         $database = $this->getDatabase();
 
         $collectionName = 'bigint_attr_validation';
-        $database->createCollection($collectionName);
+        $database->createCollection(new Collection(id: $collectionName));
 
         $this->assertTrue($database->createAttribute(
             $collectionName,
-            'signed_bigint',
-            Database::VAR_BIGINT,
-            0,
-            false,
-            signed: true
+            Attribute::bigInteger(key: 'signed_bigint'),
         ));
         $this->assertTrue($database->createAttribute(
             $collectionName,
-            'unsigned_bigint',
-            Database::VAR_BIGINT,
-            0,
-            false,
-            signed: false
+            Attribute::bigInteger(key: 'unsigned_bigint', signed: false),
         ));
 
         $collection = $database->getCollection($collectionName);
-        $attributes = $collection->getAttribute('attributes', []);
+        $attributes = $collection->attributes;
 
         $signedAttribute = null;
         $unsignedAttribute = null;
         foreach ($attributes as $attribute) {
-            if (($attribute['$id'] ?? '') === 'signed_bigint') {
+            if ($attribute->getId() === 'signed_bigint') {
                 $signedAttribute = $attribute;
             }
-            if (($attribute['$id'] ?? '') === 'unsigned_bigint') {
+            if ($attribute->getId() === 'unsigned_bigint') {
                 $unsignedAttribute = $attribute;
             }
         }
 
-        $this->assertNotNull($signedAttribute);
-        $this->assertNotNull($unsignedAttribute);
-        $this->assertTrue($signedAttribute['signed']);
-        $this->assertFalse($unsignedAttribute['signed']);
-        $this->assertEquals(0, $signedAttribute['size']);
-        $this->assertEquals(0, $unsignedAttribute['size']);
-
-        $largeUnsignedAttribute = [[
-            '$id' => 'unsigned_bigint_large',
-            'type' => Database::VAR_BIGINT,
-            'size' => 0,
-            'required' => false,
-            'signed' => false,
-            'default' => '18446744073709551615'
-        ]];
-        $this->assertTrue($database->createAttributes($collectionName, $largeUnsignedAttribute));
+        $this->assertInstanceOf(Document::class, $signedAttribute);
+        $this->assertInstanceOf(Document::class, $unsignedAttribute);
+        $this->assertTrue($signedAttribute->getAttribute('signed'));
+        $this->assertFalse($unsignedAttribute->getAttribute('signed'));
+        $this->assertSame(0, $signedAttribute->getAttribute('size'));
+        $this->assertSame(0, $unsignedAttribute->getAttribute('size'));
+
+        $largeUnsignedAttribute = [Attribute::bigInteger(key: 'unsigned_bigint_large', default: '18446744073709551615', signed: false)];
+        if ($database->getAdapter()->supports(Capability::UnsignedBigInt)) {
+            $this->assertTrue($database->createAttributes($collectionName, $largeUnsignedAttribute));
+        } else {
+            try {
+                $database->createAttributes($collectionName, $largeUnsignedAttribute);
+                $this->fail('Expected unsupported unsigned bigint default to be rejected');
+            } catch (DatabaseException $exception) {
+                $this->assertStringContainsString('does not match given type bigint', $exception->getMessage());
+            }
+        }
     }
 
     public function testCreateAttributesSuccessMultiple(): void
@@ -2391,33 +1979,21 @@ public function testCreateAttributesSuccessMultiple(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::BatchCreateAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
-        $attributes = [
-            [
-                '$id' => 'a',
-                'type' => Database::VAR_STRING,
-                'size' => 10,
-                'required' => false
-            ],
-            [
-                '$id' => 'b',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false
-            ],
-        ];
+        $attributes = [Attribute::string(key: 'a', size: 10), Attribute::integer(key: 'b')];
 
         $result = $database->createAttributes(__FUNCTION__, $attributes);
         $this->assertTrue($result);
 
         $collection = $database->getCollection(__FUNCTION__);
-        $attrs = $collection->getAttribute('attributes');
+        $attrs = $collection->attributes;
         $this->assertCount(2, $attrs);
         $this->assertEquals('a', $attrs[0]['$id']);
         $this->assertEquals('b', $attrs[1]['$id']);
@@ -2436,33 +2012,21 @@ public function testCreateAttributesDelete(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::BatchCreateAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
-        $attributes = [
-            [
-                '$id' => 'a',
-                'type' => Database::VAR_STRING,
-                'size' => 10,
-                'required' => false
-            ],
-            [
-                '$id' => 'b',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false
-            ],
-        ];
+        $attributes = [Attribute::string(key: 'a', size: 10), Attribute::integer(key: 'b')];
 
         $result = $database->createAttributes(__FUNCTION__, $attributes);
         $this->assertTrue($result);
 
         $collection = $database->getCollection(__FUNCTION__);
-        $attrs = $collection->getAttribute('attributes');
+        $attrs = $collection->attributes;
         $this->assertCount(2, $attrs);
         $this->assertEquals('a', $attrs[0]['$id']);
         $this->assertEquals('b', $attrs[1]['$id']);
@@ -2470,33 +2034,30 @@ public function testCreateAttributesDelete(): void
         $database->deleteAttribute(__FUNCTION__, 'a');
 
         $collection = $database->getCollection(__FUNCTION__);
-        $attrs = $collection->getAttribute('attributes');
+        $attrs = $collection->attributes;
         $this->assertCount(1, $attrs);
         $this->assertEquals('b', $attrs[0]['$id']);
     }
 
-    /**
-     * @depends testCreateDeleteAttribute
-     */
     public function testStringTypeAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('stringTypes');
+        $database->createCollection(new Collection(id: 'stringTypes'));
 
         // Create attributes with different string types
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'varchar_field', Database::VAR_VARCHAR, 255, false, 'default varchar'));
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'text_field', Database::VAR_TEXT, 65535, false));
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'mediumtext_field', Database::VAR_MEDIUMTEXT, 16777215, false));
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'longtext_field', Database::VAR_LONGTEXT, 4294967295, false));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::varchar(key: 'varchar_field', default: 'default varchar')));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::text(key: 'text_field', size: 65535)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::mediumText(key: 'mediumtext_field', size: 16777215)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::longText(key: 'longtext_field', size: 4294967295)));
 
         // Test with array types
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'varchar_array', Database::VAR_VARCHAR, 128, false, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('stringTypes', 'text_array', Database::VAR_TEXT, 65535, false, null, true, true));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::varchar(key: 'varchar_array', size: 128, array: true)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', Attribute::text(key: 'text_array', size: 65535, array: true)));
 
         $collection = $database->getCollection('stringTypes');
-        $this->assertCount(6, $collection->getAttribute('attributes'));
+        $this->assertCount(6, $collection->attributes);
 
         // Test VARCHAR with valid data
         $doc1 = $database->createDocument('stringTypes', new Document([
@@ -2549,7 +2110,7 @@ public function testStringTypeAttributes(): void
         $this->assertEquals([\str_repeat('x', 1000), \str_repeat('y', 2000)], $doc3->getAttribute('text_array'));
 
         // Test VARCHAR size constraint (should fail) - only for adapters that support attributes
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             try {
                 $database->createDocument('stringTypes', new Document([
                     '$id' => ID::custom('doc4'),
@@ -2585,10 +2146,10 @@ public function testStringTypeAttributes(): void
         }
 
         // Test querying by VARCHAR field
-        $this->assertEquals(true, $database->createIndex('stringTypes', 'varchar_index', Database::INDEX_KEY, ['varchar_field']));
+        $this->assertEquals(true, $database->createIndex('stringTypes', Index::key(key: 'varchar_index', attributes: ['varchar_field'])));
 
         $results = $database->find('stringTypes', [
-            Query::equal('varchar_field', ['This is a varchar field with 255 max length'])
+            Query::equal('varchar_field', ['This is a varchar field with 255 max length']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
diff --git a/tests/e2e/Adapter/Scopes/CollectionTests.php b/tests/e2e/Adapter/Scopes/CollectionTests.php
index bcbfbe91af..ff8d3ffcb0 100644
--- a/tests/e2e/Adapter/Scopes/CollectionTests.php
+++ b/tests/e2e/Adapter/Scopes/CollectionTests.php
@@ -3,11 +3,19 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use PHPUnit\Framework\Attributes\Depends;
+use Tests\E2E\Adapter\Support\EventRecorder;
 use Utopia\Cache\Adapter\None as NoneCache;
 use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\Pool;
 use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Event;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
@@ -18,17 +26,35 @@
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 
 trait CollectionTests
 {
+    private static string $createdAtCollection = '';
+
+    protected function getCreatedAtCollection(): string
+    {
+        if (self::$createdAtCollection === '') {
+            self::$createdAtCollection = 'created_at_' . uniqid();
+        }
+        return self::$createdAtCollection;
+    }
+
     public function testCreateExistsDelete(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForSchemas()) {
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -38,15 +64,21 @@ public function testCreateExistsDelete(): void
         $this->assertEquals(true, $database->create());
     }
 
-    /**
-     * @depends testCreateExistsDelete
-     */
     public function testCreateListExistsDeleteCollection(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection('actors', permissions: [
+        // Clean up any leftover collections from prior runs
+        foreach ($database->listCollections(100) as $col) {
+            try {
+                $database->deleteCollection($col->getId());
+            } catch (\Throwable) {
+                // ignore
+            }
+        }
+
+        $database->createCollection(new Collection(id: 'actors', permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
         ]));
@@ -54,7 +86,7 @@ public function testCreateListExistsDeleteCollection(): void
         $this->assertEquals(true, $database->exists($this->testDatabase, 'actors'));
 
         // Collection names should not be unique
-        $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection('actors2', permissions: [
+        $database->createCollection(new Collection(id: 'actors2', permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
         ]));
@@ -62,11 +94,12 @@ public function testCreateListExistsDeleteCollection(): void
         $this->assertEquals(true, $database->exists($this->testDatabase, 'actors2'));
         $collection = $database->getCollection('actors2');
         $collection->setAttribute('name', 'actors'); // change name to one that exists
-        $this->assertInstanceOf('Utopia\Database\Document', $database->updateDocument(
+        $updated = $database->updateDocument(
             $collection->getCollection(),
             $collection->getId(),
             $collection
-        ));
+        );
+        $this->assertSame('actors', $updated->getAttribute('name'));
         $this->assertEquals(true, $database->deleteCollection('actors2')); // Delete collection when finished
         $this->assertCount(1, $database->listCollections());
 
@@ -81,8 +114,7 @@ public function testDatabaseHostname(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-
-        if (!$database->getAdapter()->getSupportForHostname()) {
+        if (!$database->getAdapter()->supports(Capability::Hostname)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -97,290 +129,76 @@ public function testCreateCollectionWithSchema(): void
         $database = $this->getDatabase();
 
         $attributes = [
-            new Document([
-                '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute2'),
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute3'),
-                'type' => Database::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute4'),
-                'type' => Database::VAR_ID,
-                'size' => 0,
-                'required' => false,
-                'signed' => false,
-                'array' => false,
-                'filters' => [],
-            ]),
+            Attribute::string(key: 'attribute1', size: 256),
+            Attribute::integer(key: 'attribute2'),
+            Attribute::boolean(key: 'attribute3'),
+            Attribute::id(key: 'attribute4', signed: false),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute1'],
-                'lengths' => [256],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index2'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute2'],
-                'lengths' => [],
-                'orders' => ['DESC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index3'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute3', 'attribute2'],
-                'lengths' => [],
-                'orders' => ['DESC', 'ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index4'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute4'],
-                'lengths' => [],
-                'orders' => ['DESC'],
-            ]),
+            Index::key(key: 'index1', attributes: ['attribute1'], lengths: [256], orders: [Order::Asc]),
+            Index::key(key: 'index2', attributes: ['attribute2'], orders: [Order::Desc]),
+            Index::key(key: 'index3', attributes: ['attribute3', 'attribute2'], orders: [Order::Desc, Order::Asc]),
+            Index::key(key: 'index4', attributes: ['attribute4'], orders: [Order::Desc]),
         ];
 
-        $collection = $database->createCollection('withSchema', $attributes, $indexes);
+        $collection = $database->createCollection(new Collection(id: 'withSchema', attributes: $attributes, indexes: $indexes));
 
         $this->assertEquals(false, $collection->isEmpty());
         $this->assertEquals('withSchema', $collection->getId());
 
-        $this->assertIsArray($collection->getAttribute('attributes'));
-        $this->assertCount(4, $collection->getAttribute('attributes'));
-        $this->assertEquals('attribute1', $collection->getAttribute('attributes')[0]['$id']);
-        $this->assertEquals(Database::VAR_STRING, $collection->getAttribute('attributes')[0]['type']);
-        $this->assertEquals('attribute2', $collection->getAttribute('attributes')[1]['$id']);
-        $this->assertEquals(Database::VAR_INTEGER, $collection->getAttribute('attributes')[1]['type']);
-        $this->assertEquals('attribute3', $collection->getAttribute('attributes')[2]['$id']);
-        $this->assertEquals(Database::VAR_BOOLEAN, $collection->getAttribute('attributes')[2]['type']);
-        $this->assertEquals('attribute4', $collection->getAttribute('attributes')[3]['$id']);
-        $this->assertEquals(Database::VAR_ID, $collection->getAttribute('attributes')[3]['type']);
-
-        $this->assertIsArray($collection->getAttribute('indexes'));
-        $this->assertCount(4, $collection->getAttribute('indexes'));
-        $this->assertEquals('index1', $collection->getAttribute('indexes')[0]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[0]['type']);
-        $this->assertEquals('index2', $collection->getAttribute('indexes')[1]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[1]['type']);
-        $this->assertEquals('index3', $collection->getAttribute('indexes')[2]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[2]['type']);
-        $this->assertEquals('index4', $collection->getAttribute('indexes')[3]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[3]['type']);
-
+        $this->assertCount(4, $collection->attributes);
+        $this->assertEquals('attribute1', $collection->attributes[0]['$id']);
+        $this->assertSame('attribute1', $collection->attributes[0]->key);
+        $this->assertEquals(ColumnType::String->value, $collection->attributes[0]['type']);
+        $this->assertEquals('attribute2', $collection->attributes[1]['$id']);
+        $this->assertEquals(ColumnType::Integer->value, $collection->attributes[1]['type']);
+        $this->assertEquals('attribute3', $collection->attributes[2]['$id']);
+        $this->assertEquals(ColumnType::Boolean->value, $collection->attributes[2]['type']);
+        $this->assertEquals('attribute4', $collection->attributes[3]['$id']);
+        $this->assertEquals(ColumnType::Id->value, $collection->attributes[3]['type']);
+
+        $this->assertCount(4, $collection->indexes);
+        $this->assertEquals('index1', $collection->indexes[0]['$id']);
+        $this->assertSame('index1', $collection->indexes[0]->key);
+        $this->assertEquals(IndexType::Key->value, $collection->indexes[0]['type']);
+        $this->assertEquals('index2', $collection->indexes[1]['$id']);
+        $this->assertEquals(IndexType::Key->value, $collection->indexes[1]['type']);
+        $this->assertEquals('index3', $collection->indexes[2]['$id']);
+        $this->assertEquals(IndexType::Key->value, $collection->indexes[2]['type']);
+        $this->assertEquals('index4', $collection->indexes[3]['$id']);
+        $this->assertEquals(IndexType::Key->value, $collection->indexes[3]['type']);
+
+        $fetched = $database->getCollection('withSchema');
+        $this->assertSame('attribute1', $fetched->attributes[0]->key);
 
         $database->deleteCollection('withSchema');
 
         // Test collection with dash (+attribute +index)
-        $collection2 = $database->createCollection('with-dash', [
-            new Document([
-                '$id' => ID::custom('attribute-one'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => ID::custom('index-one'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute-one'],
-                'lengths' => [256],
-                'orders' => ['ASC'],
-            ])
-        ]);
+        $collection2 = $database->createCollection(new Collection(id: 'with-dash', attributes: [
+            Attribute::string(key: 'attribute-one', size: 256),
+        ], indexes: [
+            Index::key(key: 'index-one', attributes: ['attribute-one'], lengths: [256], orders: [Order::Asc]),
+        ]));
 
         $this->assertEquals(false, $collection2->isEmpty());
         $this->assertEquals('with-dash', $collection2->getId());
-        $this->assertIsArray($collection2->getAttribute('attributes'));
-        $this->assertCount(1, $collection2->getAttribute('attributes'));
-        $this->assertEquals('attribute-one', $collection2->getAttribute('attributes')[0]['$id']);
-        $this->assertEquals(Database::VAR_STRING, $collection2->getAttribute('attributes')[0]['type']);
-        $this->assertIsArray($collection2->getAttribute('indexes'));
-        $this->assertCount(1, $collection2->getAttribute('indexes'));
-        $this->assertEquals('index-one', $collection2->getAttribute('indexes')[0]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection2->getAttribute('indexes')[0]['type']);
+        $this->assertCount(1, $collection2->attributes);
+        $this->assertEquals('attribute-one', $collection2->attributes[0]['$id']);
+        $this->assertEquals(ColumnType::String->value, $collection2->attributes[0]['type']);
+        $this->assertCount(1, $collection2->indexes);
+        $this->assertEquals('index-one', $collection2->indexes[0]['$id']);
+        $this->assertEquals(IndexType::Key->value, $collection2->indexes[0]['type']);
         $database->deleteCollection('with-dash');
     }
 
-    public function testCreateCollectionValidator(): void
-    {
-        $collections = [
-            "validatorTest",
-            "validator-test",
-            "validator_test",
-            "validator.test",
-        ];
-
-        $attributes = [
-            new Document([
-                '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
-                'size' => 2500, // longer than 768
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute-2'),
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute_3'),
-                'type' => Database::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute.4'),
-                'type' => Database::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute5'),
-                'type' => Database::VAR_STRING,
-                'size' => 2500,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ])
-        ];
-
-        $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute1'],
-                'lengths' => [256],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index-2'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute-2'],
-                'lengths' => [],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index_3'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute_3'],
-                'lengths' => [],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index.4'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute.4'],
-                'lengths' => [],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('index_2_attributes'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute1', 'attribute5'],
-                'lengths' => [200, 300],
-                'orders' => ['DESC'],
-            ]),
-        ];
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        foreach ($collections as $id) {
-            $collection = $database->createCollection($id, $attributes, $indexes);
-
-            $this->assertEquals(false, $collection->isEmpty());
-            $this->assertEquals($id, $collection->getId());
-
-            $this->assertIsArray($collection->getAttribute('attributes'));
-            $this->assertCount(5, $collection->getAttribute('attributes'));
-            $this->assertEquals('attribute1', $collection->getAttribute('attributes')[0]['$id']);
-            $this->assertEquals(Database::VAR_STRING, $collection->getAttribute('attributes')[0]['type']);
-            $this->assertEquals('attribute-2', $collection->getAttribute('attributes')[1]['$id']);
-            $this->assertEquals(Database::VAR_INTEGER, $collection->getAttribute('attributes')[1]['type']);
-            $this->assertEquals('attribute_3', $collection->getAttribute('attributes')[2]['$id']);
-            $this->assertEquals(Database::VAR_BOOLEAN, $collection->getAttribute('attributes')[2]['type']);
-            $this->assertEquals('attribute.4', $collection->getAttribute('attributes')[3]['$id']);
-            $this->assertEquals(Database::VAR_BOOLEAN, $collection->getAttribute('attributes')[3]['type']);
-
-            $this->assertIsArray($collection->getAttribute('indexes'));
-            $this->assertCount(5, $collection->getAttribute('indexes'));
-            $this->assertEquals('index1', $collection->getAttribute('indexes')[0]['$id']);
-            $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[0]['type']);
-            $this->assertEquals('index-2', $collection->getAttribute('indexes')[1]['$id']);
-            $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[1]['type']);
-            $this->assertEquals('index_3', $collection->getAttribute('indexes')[2]['$id']);
-            $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[2]['type']);
-            $this->assertEquals('index.4', $collection->getAttribute('indexes')[3]['$id']);
-            $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[3]['type']);
-
-            $database->deleteCollection($id);
-        }
-    }
-
-
-    public function testCollectionNotFound(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        try {
-            $database->find('not_exist', []);
-            $this->fail('Failed to throw Exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Collection not found', $e->getMessage());
-        }
-    }
-
     public function testSizeCollection(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('sizeTest1');
-        $database->createCollection('sizeTest2');
+        $database->createCollection(new Collection(id: 'sizeTest1'));
+        $database->createCollection(new Collection(id: 'sizeTest2'));
 
         $size1 = $database->getSizeOfCollection('sizeTest1');
         $size2 = $database->getSizeOfCollection('sizeTest2');
@@ -389,24 +207,25 @@ public function testSizeCollection(): void
         // Therefore asserting with a tolerance of 5000 bytes
         $byteDifference = 5000;
 
-        if (!$database->analyzeCollection('sizeTest2')) {
+        if (! $database->analyzeCollection('sizeTest2')) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->assertLessThan($byteDifference, $sizeDifference);
 
-        $database->createAttribute('sizeTest2', 'string1', Database::VAR_STRING, 20000, true);
-        $database->createAttribute('sizeTest2', 'string2', Database::VAR_STRING, 254 + 1, true);
-        $database->createAttribute('sizeTest2', 'string3', Database::VAR_STRING, 254 + 1, true);
-        $database->createIndex('sizeTest2', 'index', Database::INDEX_KEY, ['string1', 'string2', 'string3'], [128, 128, 128]);
+        $database->createAttribute('sizeTest2', Attribute::string(key: 'string1', size: 20000, required: true));
+        $database->createAttribute('sizeTest2', Attribute::string(key: 'string2', size: 254 + 1, required: true));
+        $database->createAttribute('sizeTest2', Attribute::string(key: 'string3', size: 254 + 1, required: true));
+        $database->createIndex('sizeTest2', Index::key(key: 'index', attributes: ['string1', 'string2', 'string3'], lengths: [128, 128, 128]));
 
         $loopCount = 100;
 
         for ($i = 0; $i < $loopCount; $i++) {
             $database->createDocument('sizeTest2', new Document([
-                '$id' => 'doc' . $i,
-                'string1' => 'string1' . $i . str_repeat('A', 10000),
+                '$id' => 'doc'.$i,
+                'string1' => 'string1'.$i.str_repeat('A', 10000),
                 'string2' => 'string2',
                 'string3' => 'string3',
             ]));
@@ -420,7 +239,7 @@ public function testSizeCollection(): void
 
         $this->getDatabase()->getAuthorization()->skip(function () use ($loopCount) {
             for ($i = 0; $i < $loopCount; $i++) {
-                $this->getDatabase()->deleteDocument('sizeTest2', 'doc' . $i);
+                $this->getDatabase()->deleteDocument('sizeTest2', 'doc'.$i);
             }
         });
 
@@ -435,8 +254,8 @@ public function testSizeCollection(): void
 
     public function testSizeCollectionOnDisk(): void
     {
-        $this->getDatabase()->createCollection('sizeTestDisk1');
-        $this->getDatabase()->createCollection('sizeTestDisk2');
+        $this->getDatabase()->createCollection(new Collection(id: 'sizeTestDisk1'));
+        $this->getDatabase()->createCollection(new Collection(id: 'sizeTestDisk2'));
 
         $size1 = $this->getDatabase()->getSizeOfCollectionOnDisk('sizeTestDisk1');
         $size2 = $this->getDatabase()->getSizeOfCollectionOnDisk('sizeTestDisk2');
@@ -446,18 +265,18 @@ public function testSizeCollectionOnDisk(): void
         $byteDifference = 5000;
         $this->assertLessThan($byteDifference, $sizeDifference);
 
-        $this->getDatabase()->createAttribute('sizeTestDisk2', 'string1', Database::VAR_STRING, 20000, true);
-        $this->getDatabase()->createAttribute('sizeTestDisk2', 'string2', Database::VAR_STRING, 254 + 1, true);
-        $this->getDatabase()->createAttribute('sizeTestDisk2', 'string3', Database::VAR_STRING, 254 + 1, true);
-        $this->getDatabase()->createIndex('sizeTestDisk2', 'index', Database::INDEX_KEY, ['string1', 'string2', 'string3'], [128, 128, 128]);
+        $this->getDatabase()->createAttribute('sizeTestDisk2', Attribute::string(key: 'string1', size: 20000, required: true));
+        $this->getDatabase()->createAttribute('sizeTestDisk2', Attribute::string(key: 'string2', size: 254 + 1, required: true));
+        $this->getDatabase()->createAttribute('sizeTestDisk2', Attribute::string(key: 'string3', size: 254 + 1, required: true));
+        $this->getDatabase()->createIndex('sizeTestDisk2', Index::key(key: 'index', attributes: ['string1', 'string2', 'string3'], lengths: [128, 128, 128]));
 
         $loopCount = 40;
 
         for ($i = 0; $i < $loopCount; $i++) {
             $this->getDatabase()->createDocument('sizeTestDisk2', new Document([
-                'string1' => 'string1' . $i,
-                'string2' => 'string2' . $i,
-                'string3' => 'string3' . $i,
+                'string1' => 'string1'.$i,
+                'string2' => 'string2'.$i,
+                'string3' => 'string3'.$i,
             ]));
         }
 
@@ -472,27 +291,28 @@ public function testSizeFullText(): void
         $database = $this->getDatabase();
 
         // SQLite does not support fulltext indexes
-        if (!$database->getAdapter()->getSupportForFulltextIndex()) {
+        if (! $database->getAdapter()->supports(Capability::Fulltext)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('fullTextSizeTest');
+        $database->createCollection(new Collection(id: 'fullTextSizeTest'));
 
         $size1 = $database->getSizeOfCollection('fullTextSizeTest');
 
-        $database->createAttribute('fullTextSizeTest', 'string1', Database::VAR_STRING, 128, true);
-        $database->createAttribute('fullTextSizeTest', 'string2', Database::VAR_STRING, 254, true);
-        $database->createAttribute('fullTextSizeTest', 'string3', Database::VAR_STRING, 254, true);
-        $database->createIndex('fullTextSizeTest', 'index', Database::INDEX_KEY, ['string1', 'string2', 'string3'], [128, 128, 128]);
+        $database->createAttribute('fullTextSizeTest', Attribute::string(key: 'string1', size: 128, required: true));
+        $database->createAttribute('fullTextSizeTest', Attribute::string(key: 'string2', size: 254, required: true));
+        $database->createAttribute('fullTextSizeTest', Attribute::string(key: 'string3', size: 254, required: true));
+        $database->createIndex('fullTextSizeTest', Index::key(key: 'index', attributes: ['string1', 'string2', 'string3'], lengths: [128, 128, 128]));
 
         $loopCount = 10;
 
         for ($i = 0; $i < $loopCount; $i++) {
             $database->createDocument('fullTextSizeTest', new Document([
-                'string1' => 'string1' . $i,
-                'string2' => 'string2' . $i,
-                'string3' => 'string3' . $i,
+                'string1' => 'string1'.$i,
+                'string2' => 'string2'.$i,
+                'string3' => 'string3'.$i,
             ]));
         }
 
@@ -500,54 +320,18 @@ public function testSizeFullText(): void
 
         $this->assertGreaterThan($size1, $size2);
 
-        $database->createIndex('fullTextSizeTest', 'fulltext_index', Database::INDEX_FULLTEXT, ['string1']);
+        $database->createIndex('fullTextSizeTest', Index::fullText(key: 'fulltext_index', attributes: ['string1']));
 
         $size3 = $database->getSizeOfCollectionOnDisk('fullTextSizeTest');
 
         $this->assertGreaterThan($size2, $size3);
     }
 
-    public function testPurgeCollectionCache(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection('redis');
-
-        $this->assertEquals(true, $database->createAttribute('redis', 'name', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('redis', 'age', Database::VAR_INTEGER, 0, true));
-
-        $database->createDocument('redis', new Document([
-            '$id' => 'doc1',
-            'name' => 'Richard',
-            'age' => 15,
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ]
-        ]));
-
-        $document = $database->getDocument('redis', 'doc1');
-
-        $this->assertEquals('Richard', $document->getAttribute('name'));
-        $this->assertEquals(15, $document->getAttribute('age'));
-
-        $this->assertEquals(true, $database->deleteAttribute('redis', 'age'));
-
-        $document = $database->getDocument('redis', 'doc1');
-        $this->assertEquals('Richard', $document->getAttribute('name'));
-        $this->assertArrayNotHasKey('age', $document);
-
-        $this->assertEquals(true, $database->createAttribute('redis', 'age', Database::VAR_INTEGER, 0, true));
-
-        $document = $database->getDocument('redis', 'doc1');
-        $this->assertEquals('Richard', $document->getAttribute('name'));
-        $this->assertArrayHasKey('age', $document);
-    }
-
     public function testSchemaAttributes(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForSchemaAttributes()) {
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\SchemaAttributes::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -556,19 +340,18 @@ public function testSchemaAttributes(): void
 
         $this->assertEmpty($db->getSchemaAttributes('no_such_collection'));
 
-        $db->createCollection($collection);
+        $db->createCollection(new Collection(id: $collection));
 
-        $db->createAttribute($collection, 'username', Database::VAR_STRING, 128, true);
-        $db->createAttribute($collection, 'story', Database::VAR_STRING, 20000, true);
-        $db->createAttribute($collection, 'string_list', Database::VAR_STRING, 128, true, null, true, true);
-        $db->createAttribute($collection, 'dob', Database::VAR_DATETIME, 0, false, '2000-06-12T14:12:55.000+00:00', true, false, null, [], ['datetime']);
+        $db->createAttribute($collection, Attribute::string(key: 'username', size: 128, required: true));
+        $db->createAttribute($collection, Attribute::string(key: 'story', size: 20000, required: true));
+        $db->createAttribute($collection, Attribute::string(key: 'string_list', size: 128, required: true, array: true));
+        $db->createAttribute($collection, Attribute::datetime(key: 'dob', default: '2000-06-12T14:12:55.000+00:00', filters: ['datetime']));
 
         $attributes = [];
         foreach ($db->getSchemaAttributes($collection) as $attribute) {
             /**
              * @var Document $attribute
              */
-
             $attributes[$attribute->getId()] = $attribute;
         }
 
@@ -608,188 +391,40 @@ public function testSchemaAttributes(): void
         }
     }
 
-    public function testRowSizeToLarge(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if ($database->getAdapter()->getDocumentSizeLimit() === 0) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-        /**
-         * getDocumentSizeLimit = 65535
-         * 65535 / 4 = 16383 MB4
-         */
-        $collection_1 = $database->createCollection('row_size_1');
-        $collection_2 = $database->createCollection('row_size_2');
-
-        $this->assertEquals(true, $database->createAttribute($collection_1->getId(), 'attr_1', Database::VAR_STRING, 16000, true));
-
-        try {
-            $database->createAttribute($collection_1->getId(), 'attr_2', Database::VAR_STRING, Database::LENGTH_KEY, true);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-        }
-
-        /**
-         * Relation takes length of Database::LENGTH_KEY so exceeding getDocumentSizeLimit
-         */
-
-        try {
-            $database->createRelationship(
-                collection: $collection_2->getId(),
-                relatedCollection: $collection_1->getId(),
-                type: Database::RELATION_ONE_TO_ONE,
-                twoWay: true,
-            );
-
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-        }
-
-        try {
-            $database->createRelationship(
-                collection: $collection_1->getId(),
-                relatedCollection: $collection_2->getId(),
-                type: Database::RELATION_ONE_TO_ONE,
-                twoWay: true,
-            );
-
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-        }
-    }
-
     public function testCreateCollectionWithSchemaIndexes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
         $attributes = [
-            new Document([
-                '$id' => ID::custom('username'),
-                'type' => Database::VAR_STRING,
-                'size' => 100,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-            ]),
-            new Document([
-                '$id' => ID::custom('cards'),
-                'type' => Database::VAR_STRING,
-                'size' => 5000,
-                'required' => false,
-                'signed' => true,
-                'array' => true,
-            ]),
+            Attribute::string(key: 'username', size: 100),
+            Attribute::string(key: 'cards', size: 5000, array: true),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('idx_username'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['username'],
-                'lengths' => [100], // Will be removed since equal to attributes size
-                'orders' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('idx_username_uid'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['username', '$id'], // to solve the same attribute mongo issue
-                'lengths' => [99, 200], // Length not equal to attributes length
-                'orders' => [Database::ORDER_DESC],
-            ]),
+            Index::key(key: 'idx_username', attributes: ['username'], lengths: [100]),
+            Index::key(key: 'idx_username_uid', attributes: ['username', '$id'], lengths: [99, 200], orders: [Order::Desc]),
         ];
 
-        if ($database->getAdapter()->getSupportForIndexArray()) {
-            $indexes[] = new Document([
-                '$id' => ID::custom('idx_cards'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['cards'],
-                'lengths' => [500], // Will be changed to Database::ARRAY_INDEX_LENGTH (255)
-                'orders' => [Database::ORDER_DESC],
-            ]);
-        }
-
-        $collection = $database->createCollection(
-            'collection98',
-            $attributes,
-            $indexes,
-            permissions: [
-                Permission::create(Role::any()),
-            ]
-        );
-
-        $this->assertEquals($collection->getAttribute('indexes')[0]['attributes'][0], 'username');
-        $this->assertEquals($collection->getAttribute('indexes')[0]['lengths'][0], null);
-
-        $this->assertEquals($collection->getAttribute('indexes')[1]['attributes'][0], 'username');
-        $this->assertEquals($collection->getAttribute('indexes')[1]['lengths'][0], 99);
-        $this->assertEquals($collection->getAttribute('indexes')[1]['orders'][0], Database::ORDER_DESC);
-
-        if ($database->getAdapter()->getSupportForIndexArray()) {
-            $this->assertEquals($collection->getAttribute('indexes')[2]['attributes'][0], 'cards');
-            $this->assertEquals($collection->getAttribute('indexes')[2]['lengths'][0], Database::MAX_ARRAY_INDEX_LENGTH);
-            $this->assertEquals($collection->getAttribute('indexes')[2]['orders'][0], null);
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            $indexes[] = Index::key(key: 'idx_cards', attributes: ['cards'], lengths: [500], orders: [Order::Desc]);
         }
-    }
-
-    public function testCollectionUpdate(): Document
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $collection = $database->createCollection('collectionUpdate', permissions: [
-            Permission::create(Role::users()),
-            Permission::read(Role::users()),
-            Permission::update(Role::users()),
-            Permission::delete(Role::users())
-        ], documentSecurity: false);
 
-        $this->assertInstanceOf(Document::class, $collection);
-
-        $collection = $database->getCollection('collectionUpdate');
-
-        $this->assertFalse($collection->getAttribute('documentSecurity'));
-        $this->assertIsArray($collection->getPermissions());
-        $this->assertCount(4, $collection->getPermissions());
-
-        $collection = $database->updateCollection('collectionUpdate', [], true);
-
-        $this->assertTrue($collection->getAttribute('documentSecurity'));
-        $this->assertIsArray($collection->getPermissions());
-        $this->assertEmpty($collection->getPermissions());
-
-        $collection = $database->getCollection('collectionUpdate');
-
-        $this->assertTrue($collection->getAttribute('documentSecurity'));
-        $this->assertIsArray($collection->getPermissions());
-        $this->assertEmpty($collection->getPermissions());
-
-        return $collection;
-    }
+        $collection = $database->createCollection(new Collection(id: 'collection98', attributes: $attributes, indexes: $indexes, permissions: [
+            Permission::create(Role::any()),
+        ]));
 
-    public function testUpdateDeleteCollectionNotFound(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals($collection->indexes[0]->attributes[0], 'username');
+        $this->assertEquals($collection->indexes[0]->lengths[0], null);
 
-        try {
-            $database->deleteCollection('not_found');
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Collection not found', $e->getMessage());
-        }
+        $this->assertEquals($collection->indexes[1]->attributes[0], 'username');
+        $this->assertEquals($collection->indexes[1]->lengths[0], 99);
+        $this->assertEquals($collection->indexes[1]->orders[0], Order::Desc);
 
-        try {
-            $database->updateCollection('not_found', [], true);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Collection not found', $e->getMessage());
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            $this->assertEquals($collection->indexes[2]->attributes[0], 'cards');
+            $this->assertEquals($collection->indexes[2]->lengths[0], Database::MAX_ARRAY_INDEX_LENGTH);
+            $this->assertEquals($collection->indexes[2]->orders[0], null);
         }
     }
 
@@ -798,12 +433,13 @@ public function testGetCollectionId(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForGetConnectionId()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\ConnectionId::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->assertIsString($database->getConnectionId());
+        $this->assertNotSame('', $database->getConnectionId());
     }
 
     public function testKeywords(): void
@@ -811,31 +447,23 @@ public function testKeywords(): void
         $database = $this->getDatabase();
         $keywords = $database->getKeywords();
 
+        if ($keywords === []) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
         // Collection name tests
         $attributes = [
-            new Document([
-                '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+            Attribute::string(key: 'attribute1', size: 256),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute1'],
-                'lengths' => [256],
-                'orders' => ['ASC'],
-            ]),
+            Index::key(key: 'index1', attributes: ['attribute1'], lengths: [256], orders: [Order::Asc]),
         ];
 
         foreach ($keywords as $keyword) {
-            $collection = $database->createCollection($keyword, $attributes, $indexes);
+            $collection = $database->createCollection(new Collection(id: $keyword, attributes: $attributes, indexes: $indexes));
             $this->assertEquals($keyword, $collection->getId());
 
             $document = $database->createDocument($keyword, new Document([
@@ -865,12 +493,12 @@ public function testKeywords(): void
 
         // Attribute name tests
         foreach ($keywords as $keyword) {
-            $collectionName = 'rk' . $keyword; // rk is shorthand for reserved-keyword. We do this since there are some limits (64 chars max)
+            $collectionName = 'rk'.$keyword; // rk is shorthand for reserved-keyword. We do this since there are some limits (64 chars max)
 
-            $collection = $database->createCollection($collectionName);
+            $collection = $database->createCollection(new Collection(id: $collectionName));
             $this->assertEquals($collectionName, $collection->getId());
 
-            $attribute = $database->createAttribute($collectionName, $keyword, Database::VAR_STRING, 128, true);
+            $attribute = $database->createAttribute($collectionName, Attribute::string(key: $keyword, size: 128, required: true));
             $this->assertEquals(true, $attribute);
 
             $document = new Document([
@@ -880,29 +508,29 @@ public function testKeywords(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-                '$id' => 'reservedKeyDocument'
+                '$id' => 'reservedKeyDocument',
             ]);
-            $document->setAttribute($keyword, 'Reserved:' . $keyword);
+            $document->setAttribute($keyword, 'Reserved:'.$keyword);
 
             $document = $database->createDocument($collectionName, $document);
             $this->assertEquals('reservedKeyDocument', $document->getId());
-            $this->assertEquals('Reserved:' . $keyword, $document->getAttribute($keyword));
+            $this->assertEquals('Reserved:'.$keyword, $document->getAttribute($keyword));
 
             $document = $database->getDocument($collectionName, 'reservedKeyDocument');
             $this->assertEquals('reservedKeyDocument', $document->getId());
-            $this->assertEquals('Reserved:' . $keyword, $document->getAttribute($keyword));
+            $this->assertEquals('Reserved:'.$keyword, $document->getAttribute($keyword));
 
             $documents = $database->find($collectionName);
             $this->assertCount(1, $documents);
             $this->assertEquals('reservedKeyDocument', $documents[0]->getId());
-            $this->assertEquals('Reserved:' . $keyword, $documents[0]->getAttribute($keyword));
+            $this->assertEquals('Reserved:'.$keyword, $documents[0]->getAttribute($keyword));
 
             $documents = $database->find($collectionName, [Query::equal($keyword, ["Reserved:{$keyword}"])]);
             $this->assertCount(1, $documents);
             $this->assertEquals('reservedKeyDocument', $documents[0]->getId());
 
             $documents = $database->find($collectionName, [
-                Query::orderDesc($keyword)
+                Query::orderDesc($keyword),
             ]);
             $this->assertCount(1, $documents);
             $this->assertEquals('reservedKeyDocument', $documents[0]->getId());
@@ -912,77 +540,32 @@ public function testKeywords(): void
         }
     }
 
-    public function testLabels(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection(
-            'labels_test',
-        ));
-        $database->createAttribute('labels_test', 'attr1', Database::VAR_STRING, 10, false);
-
-        $database->createDocument('labels_test', new Document([
-            '$id' => 'doc1',
-            'attr1' => 'value1',
-            '$permissions' => [
-                Permission::read(Role::label('reader')),
-            ],
-        ]));
-
-        $documents = $database->find('labels_test');
-
-        $this->assertEmpty($documents);
-
-        $this->getDatabase()->getAuthorization()->addRole(Role::label('reader')->toString());
-
-        $documents = $database->find('labels_test');
-
-        $this->assertCount(1, $documents);
-    }
-
-    public function testMetadata(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->setMetadata('key', 'value');
-
-        $database->createCollection('testers');
-
-        $this->assertEquals(['key' => 'value'], $database->getMetadata());
-
-        $database->resetMetadata();
-
-        $this->assertEquals([], $database->getMetadata());
-    }
-
     public function testDeleteCollectionDeletesRelationships(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('devices');
+        // Create 'testers' collection if not already created (was created by testMetadata in sequential mode)
+        if ($database->getCollection('testers')->isEmpty()) {
+            $database->createCollection(new Collection(id: 'testers'));
+        }
 
-        $database->createRelationship(
-            collection: 'testers',
-            relatedCollection: 'devices',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'tester'
-        );
+        $database->createCollection(new Collection(id: 'devices'));
+
+        $database->createRelationship(Relationship::oneToMany(collection: 'testers', relatedCollection: 'devices', twoWay: true, twoWayKey: 'tester'));
 
         $testers = $database->getCollection('testers');
         $devices = $database->getCollection('devices');
 
-        $this->assertEquals(1, \count($testers->getAttribute('attributes')));
-        $this->assertEquals(1, \count($devices->getAttribute('attributes')));
-        $this->assertEquals(1, \count($devices->getAttribute('indexes')));
+        $this->assertEquals(1, \count($testers->attributes));
+        $this->assertEquals(1, \count($devices->attributes));
+        $this->assertEquals(1, \count($devices->indexes));
 
         $database->deleteCollection('testers');
 
@@ -990,60 +573,48 @@ public function testDeleteCollectionDeletesRelationships(): void
         $devices = $database->getCollection('devices');
 
         $this->assertEquals(true, $testers->isEmpty());
-        $this->assertEquals(0, \count($devices->getAttribute('attributes')));
-        $this->assertEquals(0, \count($devices->getAttribute('indexes')));
+        $this->assertEquals(0, \count($devices->attributes));
+        $this->assertEquals(0, \count($devices->indexes));
     }
 
-
     public function testCascadeMultiDelete(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('cascadeMultiDelete1');
-        $database->createCollection('cascadeMultiDelete2');
-        $database->createCollection('cascadeMultiDelete3');
+        $database->createCollection(new Collection(id: 'cascadeMultiDelete1'));
+        $database->createCollection(new Collection(id: 'cascadeMultiDelete2'));
+        $database->createCollection(new Collection(id: 'cascadeMultiDelete3'));
 
-        $database->createRelationship(
-            collection: 'cascadeMultiDelete1',
-            relatedCollection: 'cascadeMultiDelete2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            onDelete: Database::RELATION_MUTATE_CASCADE
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'cascadeMultiDelete1', relatedCollection: 'cascadeMultiDelete2', twoWay: true, onDelete: ForeignKeyAction::Cascade));
 
-        $database->createRelationship(
-            collection: 'cascadeMultiDelete2',
-            relatedCollection: 'cascadeMultiDelete3',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            onDelete: Database::RELATION_MUTATE_CASCADE
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'cascadeMultiDelete2', relatedCollection: 'cascadeMultiDelete3', twoWay: true, onDelete: ForeignKeyAction::Cascade));
 
         $root = $database->createDocument('cascadeMultiDelete1', new Document([
             '$id' => 'cascadeMultiDelete1',
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::delete(Role::any())
+                Permission::delete(Role::any()),
             ],
             'cascadeMultiDelete2' => [
                 [
                     '$id' => 'cascadeMultiDelete2',
                     '$permissions' => [
                         Permission::read(Role::any()),
-                        Permission::delete(Role::any())
+                        Permission::delete(Role::any()),
                     ],
                     'cascadeMultiDelete3' => [
                         [
                             '$id' => 'cascadeMultiDelete3',
                             '$permissions' => [
                                 Permission::read(Role::any()),
-                                Permission::delete(Role::any())
+                                Permission::delete(Role::any()),
                             ],
                         ],
                     ],
@@ -1051,8 +622,9 @@ public function testCascadeMultiDelete(): void
             ],
         ]));
 
-        $this->assertCount(1, $root->getAttribute('cascadeMultiDelete2'));
-        $this->assertCount(1, $root->getAttribute('cascadeMultiDelete2')[0]->getAttribute('cascadeMultiDelete3'));
+        $cascade2 = $root->getDocuments('cascadeMultiDelete2');
+        $this->assertCount(1, $cascade2);
+        $this->assertCount(1, $cascade2[0]->getDocuments('cascadeMultiDelete3'));
 
         $this->assertEquals(true, $database->deleteDocument('cascadeMultiDelete1', $root->getId()));
 
@@ -1082,38 +654,45 @@ public function testSharedTables(): void
         $sharedTables = $database->getSharedTables();
         $namespace = $database->getNamespace();
         $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
 
-        if (!$database->getAdapter()->getSupportForSchemas()) {
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if ($database->exists('schema1')) {
-            $database->setDatabase('schema1')->delete();
+        $token = static::getTestToken();
+        $schema1 = 'schema1_'.$token;
+        $schema2 = 'schema2_'.$token;
+        $sharedTablesDb = 'sharedTables_'.$token;
+
+        if ($database->exists($schema1)) {
+            $database->setDatabase($schema1)->delete();
         }
-        if ($database->exists('schema2')) {
-            $database->setDatabase('schema2')->delete();
+        if ($database->exists($schema2)) {
+            $database->setDatabase($schema2)->delete();
         }
-        if ($database->exists('sharedTables')) {
-            $database->setDatabase('sharedTables')->delete();
+        if ($database->exists($sharedTablesDb)) {
+            $database->setDatabase($sharedTablesDb)->delete();
         }
 
         /**
          * Schema
          */
         $database
-            ->setDatabase('schema1')
+            ->setDatabase($schema1)
             ->setNamespace('')
             ->create();
 
-        $this->assertEquals(true, $database->exists('schema1'));
+        $this->assertEquals(true, $database->exists($schema1));
 
         $database
-            ->setDatabase('schema2')
+            ->setDatabase($schema2)
             ->setNamespace('')
             ->create();
 
-        $this->assertEquals(true, $database->exists('schema2'));
+        $this->assertEquals(true, $database->exists($schema2));
 
         /**
          * Table
@@ -1122,49 +701,30 @@ public function testSharedTables(): void
         $tenant2 = 2;
 
         $database
-            ->setDatabase('sharedTables')
+            ->setDatabase($sharedTablesDb)
             ->setNamespace('')
             ->setSharedTables(true)
             ->setTenant($tenant1)
             ->create();
 
-        $this->assertEquals(true, $database->exists('sharedTables'));
-
-        $database->createCollection('people', [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 128,
-                'required' => true,
-            ]),
-            new Document([
-                '$id' => 'lifeStory',
-                'type' => Database::VAR_STRING,
-                'size' => 65536,
-                'required' => true,
-            ])
-        ], [
-            new Document([
-                '$id' => 'idx_name',
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['name']
-            ])
-        ], [
+        $this->assertEquals(true, $database->exists($sharedTablesDb));
+
+        $database->createCollection(new Collection(id: 'people', attributes: [
+            Attribute::string(key: 'name', size: 128, required: true),
+            Attribute::string(key: 'lifeStory', size: 65536, required: true),
+        ], indexes: [
+            Index::key(key: 'idx_name', attributes: ['name']),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
         $this->assertCount(1, $database->listCollections());
 
-        if ($database->getAdapter()->getSupportForFulltextIndex()) {
-            $database->createIndex(
-                collection: 'people',
-                id: 'idx_lifeStory',
-                type: Database::INDEX_FULLTEXT,
-                attributes: ['lifeStory']
-            );
+        if ($database->getAdapter()->supports(Capability::Fulltext)) {
+            $database->createIndex('people', Index::fullText(key: 'idx_lifeStory', attributes: ['lifeStory']));
         }
 
         $docId = ID::unique();
@@ -1175,7 +735,7 @@ public function testSharedTables(): void
                 Permission::read(Role::any()),
             ],
             'name' => 'Spiderman',
-            'lifeStory' => 'Spider-Man is a superhero appearing in American comic books published by Marvel Comics.'
+            'lifeStory' => 'Spider-Man is a superhero appearing in American comic books published by Marvel Comics.',
         ]));
 
         $doc = $database->getDocument('people', $docId);
@@ -1186,7 +746,7 @@ public function testSharedTables(): void
          * Remove Permissions
          */
         $doc->setAttribute('$permissions', [
-            Permission::read(Role::any())
+            Permission::read(Role::any()),
         ]);
 
         $database->updateDocument('people', $docId, $doc);
@@ -1251,9 +811,11 @@ public function testSharedTables(): void
         // Reset state
         $database
             ->setSharedTables($sharedTables)
+            ->setTenant($tenant)
             ->setNamespace($namespace)
             ->setDatabase($schema);
     }
+
     /**
      * @throws LimitException
      * @throws DuplicateException
@@ -1264,12 +826,12 @@ public function testCreateDuplicates(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('duplicates', permissions: [
-            Permission::read(Role::any())
-        ]);
+        $database->createCollection(new Collection(id: 'duplicates', permissions: [
+            Permission::read(Role::any()),
+        ]));
 
         try {
-            $database->createCollection('duplicates');
+            $database->createCollection(new Collection(id: 'duplicates'));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
             $this->assertInstanceOf(DuplicateException::class, $e);
@@ -1279,6 +841,7 @@ public function testCreateDuplicates(): void
 
         $database->deleteCollection('duplicates');
     }
+
     public function testSharedTablesDuplicates(): void
     {
         /** @var Database $database */
@@ -1286,60 +849,66 @@ public function testSharedTablesDuplicates(): void
         $sharedTables = $database->getSharedTables();
         $namespace = $database->getNamespace();
         $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
 
-        if (!$database->getAdapter()->getSupportForSchemas()) {
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if ($database->exists('sharedTables')) {
-            $database->setDatabase('sharedTables')->delete();
+        $sharedTablesDb = 'sharedTables_'.static::getTestToken();
+
+        if ($database->exists($sharedTablesDb)) {
+            $database->setDatabase($sharedTablesDb)->delete();
         }
 
         $database
-            ->setDatabase('sharedTables')
+            ->setDatabase($sharedTablesDb)
             ->setNamespace('')
             ->setSharedTables(true)
             ->setTenant(null)
             ->create();
 
         // Create collection
-        $database->createCollection('duplicates', documentSecurity: false);
-        $database->createAttribute('duplicates', 'name', Database::VAR_STRING, 10, false);
-        $database->createIndex('duplicates', 'nameIndex', Database::INDEX_KEY, ['name']);
+        $database->createCollection(new Collection(id: 'duplicates', documentSecurity: false));
+        $database->createAttribute('duplicates', Attribute::string(key: 'name', size: 10));
+        $database->createIndex('duplicates', Index::key(key: 'nameIndex', attributes: ['name']));
 
         $database->setTenant(2);
 
         try {
-            $database->createCollection('duplicates', documentSecurity: false);
+            $database->createCollection(new Collection(id: 'duplicates', documentSecurity: false));
         } catch (DuplicateException) {
             // Ignore
         }
 
         try {
-            $database->createAttribute('duplicates', 'name', Database::VAR_STRING, 10, false);
+            $database->createAttribute('duplicates', Attribute::string(key: 'name', size: 10));
         } catch (DuplicateException) {
             // Ignore
         }
 
         try {
-            $database->createIndex('duplicates', 'nameIndex', Database::INDEX_KEY, ['name']);
+            $database->createIndex('duplicates', Index::key(key: 'nameIndex', attributes: ['name']));
         } catch (DuplicateException) {
             // Ignore
         }
 
         $collection = $database->getCollection('duplicates');
-        $this->assertEquals(1, \count($collection->getAttribute('attributes')));
-        $this->assertEquals(1, \count($collection->getAttribute('indexes')));
+        $this->assertEquals(1, \count($collection->attributes));
+        $this->assertEquals(1, \count($collection->indexes));
 
-        $database->setTenant(1);
+        $database->setTenant(null);
+        $database->purgeCachedCollection('duplicates');
 
         $collection = $database->getCollection('duplicates');
-        $this->assertEquals(1, \count($collection->getAttribute('attributes')));
-        $this->assertEquals(1, \count($collection->getAttribute('indexes')));
+        $this->assertEquals(1, \count($collection->attributes));
+        $this->assertEquals(1, \count($collection->indexes));
 
         $database
             ->setSharedTables($sharedTables)
+            ->setTenant($tenant)
             ->setNamespace($namespace)
             ->setDatabase($schema);
     }
@@ -1356,7 +925,7 @@ public function testSharedTablesMultiTenantCreateCollection(): void
 
         if ($sharedTables) {
             // Already in shared-tables mode (SharedTables/* test classes)
-        } elseif ($database->getAdapter()->getSupportForSchemas()) {
+        } elseif ($database->getAdapter()->supports(Capability::Schemas)) {
             $dbName = 'stMultiTenant';
             if ($database->exists($dbName)) {
                 $database->setDatabase($dbName)->delete();
@@ -1370,43 +939,34 @@ public function testSharedTablesMultiTenantCreateCollection(): void
             $createdDb = true;
         } else {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         try {
-            $tenant1 = $database->getAdapter()->getIdAttributeType() === Database::VAR_INTEGER ? 10 : 'tenant_10';
-            $tenant2 = $database->getAdapter()->getIdAttributeType() === Database::VAR_INTEGER ? 20 : 'tenant_20';
-            $colName = 'multiTenantCol';
+            $tenant1 = $database->getAdapter()->getIdAttributeType() === ColumnType::Integer->value ? 10 : 'tenant_10';
+            $tenant2 = $database->getAdapter()->getIdAttributeType() === ColumnType::Integer->value ? 20 : 'tenant_20';
+            $colName = 'mt_' . uniqid();
 
             $database->setTenant($tenant1);
 
-            $database->createCollection($colName, [
-                new Document([
-                    '$id' => 'name',
-                    'type' => Database::VAR_STRING,
-                    'size' => 128,
-                    'required' => true,
-                ]),
-            ]);
+            $database->createCollection(new Collection(id: $colName, attributes: [
+                Attribute::string(key: 'name', size: 128, required: true),
+            ]));
 
             $col1 = $database->getCollection($colName);
             $this->assertFalse($col1->isEmpty());
-            $this->assertEquals(1, \count($col1->getAttribute('attributes')));
+            $this->assertEquals(1, \count($col1->attributes));
 
             $database->setTenant($tenant2);
 
-            $database->createCollection($colName, [
-                new Document([
-                    '$id' => 'name',
-                    'type' => Database::VAR_STRING,
-                    'size' => 128,
-                    'required' => true,
-                ]),
-            ]);
+            $database->createCollection(new Collection(id: $colName, attributes: [
+                Attribute::string(key: 'name', size: 128, required: true),
+            ]));
 
             $col2 = $database->getCollection($colName);
             $this->assertFalse($col2->isEmpty());
-            $this->assertEquals(1, \count($col2->getAttribute('attributes')));
+            $this->assertEquals(1, \count($col2->attributes));
 
             $database->setTenant($tenant1);
             $col1Again = $database->getCollection($colName);
@@ -1417,8 +977,11 @@ public function testSharedTablesMultiTenantCreateCollection(): void
             } else {
                 $database->setTenant($tenant1);
                 $database->deleteCollection($colName);
-                $database->setTenant($tenant2);
-                $database->deleteCollection($colName);
+                try {
+                    $database->setTenant($tenant2);
+                    $database->deleteCollection($colName);
+                } catch (\Throwable) {
+                }
             }
         } finally {
             $database
@@ -1439,8 +1002,8 @@ public function testSharedTablesMultiTenantCreate(): void
         $originalTenant = $database->getTenant();
 
         try {
-            $tenant1 = $database->getAdapter()->getIdAttributeType() === Database::VAR_INTEGER ? 100 : 'tenant_100';
-            $tenant2 = $database->getAdapter()->getIdAttributeType() === Database::VAR_INTEGER ? 200 : 'tenant_200';
+            $tenant1 = $database->getAdapter()->getIdAttributeType() === ColumnType::Integer->value ? 100 : 'tenant_100';
+            $tenant2 = $database->getAdapter()->getIdAttributeType() === ColumnType::Integer->value ? 200 : 'tenant_200';
 
             if ($sharedTables) {
                 // Already in shared-tables mode; create() should be idempotent.
@@ -1450,8 +1013,8 @@ public function testSharedTablesMultiTenantCreate(): void
                 $database->create();
                 $database->setTenant($tenant2);
                 $database->create();
-                $this->assertTrue(true);
-            } elseif ($database->getAdapter()->getSupportForSchemas()) {
+                $this->assertSame($tenant2, $database->getTenant());
+            } elseif ($database->getAdapter()->supports(Capability::Schemas)) {
                 $dbName = 'stMultiCreate';
                 if ($database->exists($dbName)) {
                     $database->setDatabase($dbName)->delete();
@@ -1469,6 +1032,7 @@ public function testSharedTablesMultiTenantCreate(): void
                 $database->delete();
             } else {
                 $this->expectNotToPerformAssertions();
+
                 return;
             }
         } finally {
@@ -1486,60 +1050,59 @@ public function testEvents(): void
             $database = $this->getDatabase();
 
             $events = [
-                Database::EVENT_DATABASE_CREATE,
-                Database::EVENT_DATABASE_LIST,
-                Database::EVENT_COLLECTION_CREATE,
-                Database::EVENT_COLLECTION_LIST,
-                Database::EVENT_COLLECTION_READ,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_ATTRIBUTE_CREATE,
-                Database::EVENT_ATTRIBUTE_UPDATE,
-                Database::EVENT_INDEX_CREATE,
-                Database::EVENT_DOCUMENT_CREATE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_UPDATE,
-                Database::EVENT_DOCUMENT_READ,
-                Database::EVENT_DOCUMENT_FIND,
-                Database::EVENT_DOCUMENT_FIND,
-                Database::EVENT_DOCUMENT_COUNT,
-                Database::EVENT_DOCUMENT_SUM,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_INCREASE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_DECREASE,
-                Database::EVENT_DOCUMENTS_CREATE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENTS_UPDATE,
-                Database::EVENT_INDEX_DELETE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_DELETE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENTS_DELETE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_ATTRIBUTE_DELETE,
-                Database::EVENT_COLLECTION_DELETE,
-                Database::EVENT_DATABASE_DELETE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_DOCUMENTS_DELETE,
-                Database::EVENT_DOCUMENT_PURGE,
-                Database::EVENT_ATTRIBUTE_DELETE,
-                Database::EVENT_COLLECTION_DELETE,
-                Database::EVENT_DATABASE_DELETE
+                Event::DatabaseCreate,
+                Event::DatabaseList,
+                Event::CollectionCreate,
+                Event::CollectionList,
+                Event::CollectionRead,
+                Event::DocumentPurge,
+                Event::AttributeCreate,
+                Event::AttributeUpdate,
+                Event::IndexCreate,
+                Event::DocumentCreate,
+                Event::DocumentPurge,
+                Event::DocumentUpdate,
+                Event::DocumentRead,
+                Event::DocumentFind,
+                Event::DocumentFind,
+                Event::DocumentCount,
+                Event::DocumentSum,
+                Event::DocumentPurge,
+                Event::DocumentIncrease,
+                Event::DocumentPurge,
+                Event::DocumentDecrease,
+                Event::DocumentsCreate,
+                Event::DocumentPurge,
+                Event::DocumentPurge,
+                Event::DocumentPurge,
+                Event::DocumentsUpdate,
+                Event::IndexDelete,
+                Event::DocumentPurge,
+                Event::DocumentDelete,
+                Event::DocumentPurge,
+                Event::DocumentPurge,
+                Event::DocumentsDelete,
+                Event::DocumentPurge,
+                Event::AttributeDelete,
+                Event::CollectionDelete,
+                Event::DatabaseDelete,
+                Event::DocumentPurge,
+                Event::DocumentsDelete,
+                Event::DocumentPurge,
+                Event::AttributeDelete,
+                Event::CollectionDelete,
+                Event::DatabaseDelete,
             ];
 
-            $database->on(Database::EVENT_ALL, 'test', function ($event, $data) use (&$events) {
-                $shifted = array_shift($events);
-                $this->assertEquals($shifted, $event);
-            });
+            $supportsSchemas = $this->getDatabase()->getAdapter()->supports(Capability::Schemas);
+            if (! $supportsSchemas) {
+                \array_shift($events);
+            }
+            $database->addHook(new EventRecorder($events, $this));
 
-            if ($this->getDatabase()->getAdapter()->getSupportForSchemas()) {
+            if ($supportsSchemas) {
                 $database->setDatabase('hellodb');
                 $database->create();
-            } else {
-                \array_shift($events);
             }
 
             $database->list();
@@ -1547,13 +1110,13 @@ public function testEvents(): void
             $database->setDatabase($this->testDatabase);
 
             $collectionId = ID::unique();
-            $database->createCollection($collectionId);
+            $database->createCollection(new Collection(id: $collectionId));
             $database->listCollections();
             $database->getCollection($collectionId);
-            $database->createAttribute($collectionId, 'attr1', Database::VAR_INTEGER, 2, false);
+            $database->createAttribute($collectionId, Attribute::integer(key: 'attr1', size: 2));
             $database->updateAttributeRequired($collectionId, 'attr1', true);
-            $indexId1 = 'index2_' . uniqid();
-            $database->createIndex($collectionId, $indexId1, Database::INDEX_KEY, ['attr1']);
+            $indexId1 = 'index2_'.uniqid();
+            $database->createIndex($collectionId, Index::key(key: $indexId1, attributes: ['attr1']));
 
             $document = $database->createDocument($collectionId, new Document([
                 '$id' => 'doc1',
@@ -1565,11 +1128,6 @@ public function testEvents(): void
                 ],
             ]));
 
-            $executed = false;
-            $database->on(Database::EVENT_ALL, 'should-not-execute', function ($event, $data) use (&$executed) {
-                $executed = true;
-            });
-
             $database->silent(function () use ($database, $collectionId, $document) {
                 $database->updateDocument($collectionId, 'doc1', $document->setAttribute('attr1', 15));
                 $database->getDocument($collectionId, 'doc1');
@@ -1579,9 +1137,7 @@ public function testEvents(): void
                 $database->sum($collectionId, 'attr1');
                 $database->increaseDocumentAttribute($collectionId, $document->getId(), 'attr1');
                 $database->decreaseDocumentAttribute($collectionId, $document->getId(), 'attr1');
-            }, ['should-not-execute']);
-
-            $this->assertFalse($executed);
+            });
 
             $database->createDocuments($collectionId, [
                 new Document([
@@ -1603,10 +1159,6 @@ public function testEvents(): void
             $database->deleteAttribute($collectionId, 'attr1');
             $database->deleteCollection($collectionId);
             $database->delete('hellodb');
-
-            // Remove all listeners
-            $database->on(Database::EVENT_ALL, 'test', null);
-            $database->on(Database::EVENT_ALL, 'should-not-execute', null);
         });
     }
 
@@ -1615,9 +1167,10 @@ public function testCreatedAtUpdatedAt(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection('created_at'));
-        $database->createAttribute('created_at', 'title', Database::VAR_STRING, 100, false);
-        $document = $database->createDocument('created_at', new Document([
+        $created = $database->createCollection(new Collection(id: $this->getCreatedAtCollection()));
+        $this->assertSame($this->getCreatedAtCollection(), $created->getId());
+        $database->createAttribute($this->getCreatedAtCollection(), Attribute::string(key: 'title', size: 100));
+        $document = $database->createDocument($this->getCreatedAtCollection(), new Document([
             '$id' => ID::custom('uid123'),
 
             '$permissions' => [
@@ -1632,66 +1185,63 @@ public function testCreatedAtUpdatedAt(): void
         $this->assertNotNull($document->getSequence());
     }
 
-    /**
-     * @depends testCreatedAtUpdatedAt
-     */
+    #[Depends('testCreatedAtUpdatedAt')]
     public function testCreatedAtUpdatedAtAssert(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->getDocument('created_at', 'uid123');
-        $this->assertEquals(true, !$document->isEmpty());
+        $document = $database->getDocument($this->getCreatedAtCollection(), 'uid123');
+        $this->assertEquals(true, ! $document->isEmpty());
         sleep(1);
         $document->setAttribute('title', 'new title');
-        $database->updateDocument('created_at', 'uid123', $document);
-        $document = $database->getDocument('created_at', 'uid123');
+        $database->updateDocument($this->getCreatedAtCollection(), 'uid123', $document);
+        $document = $database->getDocument($this->getCreatedAtCollection(), 'uid123');
 
         $this->assertGreaterThan($document->getCreatedAt(), $document->getUpdatedAt());
         $this->expectException(DuplicateException::class);
 
-        $database->createCollection('created_at');
+        $database->createCollection(new Collection(id: $this->getCreatedAtCollection()));
     }
 
-
     public function testTransformations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('docs', attributes: [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 767,
-                'required' => true,
-            ])
-        ]);
+        $database->createCollection(new Collection(id: 'docs', attributes: [
+            Attribute::string(key: 'name', size: 767, required: true),
+        ]));
 
         $database->createDocument('docs', new Document([
             '$id' => 'doc1',
+            '$permissions' => [Permission::read(Role::any())],
             'name' => 'value1',
         ]));
 
-        $database->setMetadata('scope', 'api.users');
-
-        $capturedSql = '';
-        $database->before(Database::EVENT_DOCUMENT_READ, 'test', function (string $sql) use (&$capturedSql) {
-            $sql .= ' AND 1=0';
-            $capturedSql = $sql;
-            return $sql;
-        });
-
-        $result = $database->getDocument('docs', 'doc1');
+        $collection = $database->getCollection('docs');
+        $adapter = $database->getAdapter();
+        $hook = new class () implements Transform {
+            public function transform(Event $event, string $query): string
+            {
+                return $query.' AND 1 = 0';
+            }
+        };
+        $database->addHook($hook);
 
-        $this->assertTrue($result->isEmpty());
+        try {
+            $result = $adapter->getDocument($collection, 'doc1');
 
-        if ($database->getAdapter() instanceof SQL) {
-            $this->assertStringContainsString('/* scope: api.users */', $capturedSql);
+            if ($adapter instanceof SQL || $adapter instanceof Pool) {
+                $this->assertTrue($result->isEmpty());
+            } else {
+                $this->assertFalse($result->isEmpty());
+            }
+        } finally {
+            $database->removeTransform($hook::class);
         }
 
-        $database->before(Database::EVENT_DOCUMENT_READ, 'test', null);
-        $database->resetMetadata();
+        $this->assertFalse($adapter->getDocument($collection, 'doc1')->isEmpty());
     }
 
     public function testSetGlobalCollection(): void
@@ -1715,17 +1265,22 @@ public function testSetGlobalCollection(): void
         $this->assertNotEmpty($hashKey);
 
         if ($db->getSharedTables()) {
-            $this->assertStringNotContainsString((string)$db->getAdapter()->getTenant(), $collectionKey);
+            // Cache key format: '<cache>-<host>:<namespace>:<tenant>:collection:<id>'.
+            // Substring matching is unsafe because the namespace is a hex
+            // uniqid() that may legitimately contain the tenant digits.
+            $tenantSegment = \explode(':', $collectionKey)[2] ?? null;
+            $this->assertSame('', $tenantSegment);
         }
 
-        // non global collection should containt tenant in the cache key
+        // non global collection should contain tenant in the cache key
         $nonGlobalCollectionId = 'nonGlobalCollection';
         [$collectionKeyRegular] = $db->getCacheKeys(
             Database::METADATA,
             $nonGlobalCollectionId
         );
         if ($db->getSharedTables()) {
-            $this->assertStringContainsString((string)$db->getAdapter()->getTenant(), $collectionKeyRegular);
+            $tenantSegment = \explode(':', $collectionKeyRegular)[2] ?? null;
+            $this->assertSame((string) $db->getAdapter()->getTenant(), $tenantSegment);
         }
 
         // Non metadata collection should contain tenant in the cache key
@@ -1740,81 +1295,46 @@ public function testSetGlobalCollection(): void
         $this->assertNotEmpty($hashKey);
 
         if ($db->getSharedTables()) {
-            $this->assertStringContainsString((string)$db->getAdapter()->getTenant(), $collectionKey);
+            $this->assertStringContainsString((string) $db->getAdapter()->getTenant(), $collectionKey);
         }
 
         $db->resetGlobalCollections();
         $this->assertEmpty($db->getGlobalCollections());
-
     }
 
     public function testCreateCollectionWithLongId(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collection = '019a91aa-58cd-708d-a55c-5f7725ef937a';
 
         $attributes = [
-            new Document([
-                '$id' => 'name',
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => true,
-                'array' => false,
-            ]),
-            new Document([
-                '$id' => 'age',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false,
-                'array' => false,
-            ]),
-            new Document([
-                '$id' => 'isActive',
-                'type' => Database::VAR_BOOLEAN,
-                'size' => 0,
-                'required' => false,
-                'array' => false,
-            ]),
+            Attribute::string(key: 'name', size: 256, required: true),
+            Attribute::integer(key: 'age'),
+            Attribute::boolean(key: 'isActive'),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('idx_name'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['name'],
-                'lengths' => [128],
-                'orders' => ['ASC'],
-            ]),
-            new Document([
-                '$id' => ID::custom('idx_name_age'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['name', 'age'],
-                'lengths' => [128, null],
-                'orders' => ['ASC', 'DESC'],
-            ]),
+            Index::key(key: 'idx_name', attributes: ['name'], lengths: [128], orders: [Order::Asc]),
+            Index::key(key: 'idx_name_age', attributes: ['name', 'age'], lengths: [128, null], orders: [Order::Asc, Order::Desc]),
         ];
 
-        $collectionDocument = $database->createCollection(
-            $collection,
-            $attributes,
-            $indexes,
-            permissions: [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-        );
+        $collectionDocument = $database->createCollection(new Collection(id: $collection, attributes: $attributes, indexes: $indexes, permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]));
 
         $this->assertEquals($collection, $collectionDocument->getId());
-        $this->assertCount(3, $collectionDocument->getAttribute('attributes'));
-        $this->assertCount(2, $collectionDocument->getAttribute('indexes'));
+        $this->assertCount(3, $collectionDocument->attributes);
+        $this->assertCount(2, $collectionDocument->indexes);
 
         $document = $database->createDocument($collection, new Document([
             '$id' => 'longIdDoc',
@@ -1860,22 +1380,18 @@ public function testCreateCollectionConcurrentlyKeepsPeerData(): void
 
         // A peer process: same database, its own cache, so its writes do not
         // purge the negative cache entry this process is about to record.
+        $authorization = self::$authorization ?? throw new \RuntimeException('Authorization not initialised');
         $peer = (new Database($database->getAdapter(), new Cache(new NoneCache())))
-            ->setAuthorization(self::$authorization);
+            ->setAuthorization($authorization);
 
         $this->assertTrue($database->getCollection($collection)->isEmpty());
 
-        $peer->createCollection($collection, [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'size' => 128,
-                'required' => false,
-            ]),
-        ], permissions: [
+        $name = Attribute::string(key: 'name', size: 128);
+
+        $peer->createCollection(new Collection(id: $collection, attributes: [$name], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ]));
 
         $peer->createDocument($collection, new Document([
             '$id' => ID::custom('written'),
@@ -1884,17 +1400,10 @@ public function testCreateCollectionConcurrentlyKeepsPeerData(): void
         ]));
 
         try {
-            $database->createCollection($collection, [
-                new Document([
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'size' => 128,
-                    'required' => false,
-                ]),
-            ], permissions: [
+            $database->createCollection(new Collection(id: $collection, attributes: [$name], permissions: [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
-            ]);
+            ]));
             $this->fail('Expected DuplicateException for a collection a peer already created');
         } catch (DuplicateException) {
         }
@@ -1932,12 +1441,7 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
         }
 
         $collection = 'preCommitCreate';
-        $name = new Document([
-            '$id' => ID::custom('name'),
-            'type' => Database::VAR_STRING,
-            'size' => 128,
-            'required' => false,
-        ]);
+        $name = Attribute::string(key: 'name', size: 128);
 
         $database->getAdapter()->createCollection($collection, [$name], []);
 
@@ -1945,7 +1449,7 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
             '$id' => $collection,
             '$collection' => Database::METADATA,
             'name' => $collection,
-            'attributes' => [$name],
+            'attributes' => [$name->toDocument()],
             'indexes' => [],
             'documentSecurity' => true,
             '$permissions' => [
@@ -1963,10 +1467,10 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
         ]));
 
         try {
-            $database->createCollection($collection, [$name], permissions: [
+            $database->createCollection(new Collection(id: $collection, attributes: [$name], permissions: [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
-            ]);
+            ]));
         } catch (DuplicateException) {
             // SQL adapters report the existing table as Duplicate. Mongo's
             // createCollection is idempotent, so this process continues and
diff --git a/tests/e2e/Adapter/Scopes/CustomDocumentTypeTests.php b/tests/e2e/Adapter/Scopes/CustomDocumentTypeTests.php
deleted file mode 100644
index 9953e73e22..0000000000
--- a/tests/e2e/Adapter/Scopes/CustomDocumentTypeTests.php
+++ /dev/null
@@ -1,313 +0,0 @@
-<?php
-
-namespace Tests\E2E\Adapter\Scopes;
-
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Exception as DatabaseException;
-use Utopia\Database\Helpers\ID;
-use Utopia\Database\Helpers\Permission;
-use Utopia\Database\Helpers\Role;
-use Utopia\Database\Query;
-
-// Test custom document classes
-class TestUser extends Document
-{
-    public function getEmail(): string
-    {
-        return $this->getAttribute('email', '');
-    }
-
-    public function getName(): string
-    {
-        return $this->getAttribute('name', '');
-    }
-
-    public function isActive(): bool
-    {
-        return $this->getAttribute('status') === 'active';
-    }
-}
-
-class TestPost extends Document
-{
-    public function getTitle(): string
-    {
-        return $this->getAttribute('title', '');
-    }
-
-    public function getContent(): string
-    {
-        return $this->getAttribute('content', '');
-    }
-}
-
-trait CustomDocumentTypeTests
-{
-    public function testSetDocumentType(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $database->setDocumentType('users', TestUser::class);
-
-        $this->assertEquals(
-            TestUser::class,
-            $database->getDocumentType('users')
-        );
-
-        // Cleanup
-        $database->clearDocumentType('users');
-    }
-
-    public function testGetDocumentTypeReturnsNull(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $this->assertNull($database->getDocumentType('nonexistent_collection'));
-
-        // No cleanup needed - no types were set
-    }
-
-    public function testSetDocumentTypeWithInvalidClass(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('does not exist');
-
-        // @phpstan-ignore-next-line - Testing with invalid class name
-        $database->setDocumentType('users', 'NonExistentClass');
-    }    public function testSetDocumentTypeWithNonDocumentClass(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('must extend');
-
-        // @phpstan-ignore-next-line - Testing with non-Document class
-        $database->setDocumentType('users', \stdClass::class);
-    }
-
-    public function testClearDocumentType(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $database->setDocumentType('users', TestUser::class);
-        $this->assertEquals(TestUser::class, $database->getDocumentType('users'));
-
-        $database->clearDocumentType('users');
-        $this->assertNull($database->getDocumentType('users'));
-    }
-
-    public function testClearAllDocumentTypes(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $database->setDocumentType('users', TestUser::class);
-        $database->setDocumentType('posts', TestPost::class);
-
-        $this->assertEquals(TestUser::class, $database->getDocumentType('users'));
-        $this->assertEquals(TestPost::class, $database->getDocumentType('posts'));
-
-        $database->clearAllDocumentTypes();
-
-        $this->assertNull($database->getDocumentType('users'));
-        $this->assertNull($database->getDocumentType('posts'));
-    }
-
-    public function testMethodChaining(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $result = $database->setDocumentType('users', TestUser::class);
-
-        $this->assertInstanceOf(Database::class, $result);
-
-        $database
-            ->setDocumentType('users', TestUser::class)
-            ->setDocumentType('posts', TestPost::class);
-
-        $this->assertEquals(TestUser::class, $database->getDocumentType('users'));
-        $this->assertEquals(TestPost::class, $database->getDocumentType('posts'));
-
-        // Cleanup to prevent test pollution
-        $database->clearAllDocumentTypes();
-    }
-
-    public function testCustomDocumentTypeWithGetDocument(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Create collection
-        $database->createCollection('customUsers', permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
-
-        $database->createAttribute('customUsers', 'email', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customUsers', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customUsers', 'status', Database::VAR_STRING, 50, true);
-
-        $database->setDocumentType('customUsers', TestUser::class);
-
-        /** @var TestUser $created */
-        $created = $database->createDocument('customUsers', new Document([
-            '$id' => ID::unique(),
-            'email' => 'test@example.com',
-            'name' => 'Test User',
-            'status' => 'active',
-            '$permissions' => [Permission::read(Role::any())],
-        ]));
-
-        // Verify it's a TestUser instance
-        $this->assertInstanceOf(TestUser::class, $created);
-        $this->assertEquals('test@example.com', $created->getEmail());
-        $this->assertEquals('Test User', $created->getName());
-        $this->assertTrue($created->isActive());
-
-        // Get document and verify type
-        /** @var TestUser $fetched */
-        $fetched = $database->getDocument('customUsers', $created->getId());
-        $this->assertInstanceOf(TestUser::class, $fetched);
-        $this->assertEquals('test@example.com', $fetched->getEmail());
-        $this->assertTrue($fetched->isActive());
-
-        // Cleanup
-        $database->deleteCollection('customUsers');
-        $database->clearDocumentType('customUsers');
-    }
-
-    public function testCustomDocumentTypeWithFind(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Create collection
-        $database->createCollection('customPosts', permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-        ]);
-
-        $database->createAttribute('customPosts', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customPosts', 'content', Database::VAR_STRING, 5000, true);
-
-        // Register custom type
-        $database->setDocumentType('customPosts', TestPost::class);
-
-        // Create multiple documents
-        $post1 = $database->createDocument('customPosts', new Document([
-            '$id' => ID::unique(),
-            'title' => 'First Post',
-            'content' => 'This is the first post',
-            '$permissions' => [Permission::read(Role::any())],
-        ]));
-
-        $post2 = $database->createDocument('customPosts', new Document([
-            '$id' => ID::unique(),
-            'title' => 'Second Post',
-            'content' => 'This is the second post',
-            '$permissions' => [Permission::read(Role::any())],
-        ]));
-
-        // Find documents
-        /** @var TestPost[] $posts */
-        $posts = $database->find('customPosts', [Query::limit(10)]);
-
-        $this->assertCount(2, $posts);
-        $this->assertInstanceOf(TestPost::class, $posts[0]);
-        $this->assertInstanceOf(TestPost::class, $posts[1]);
-        $this->assertEquals('First Post', $posts[0]->getTitle());
-        $this->assertEquals('Second Post', $posts[1]->getTitle());
-
-        // Cleanup
-        $database->deleteCollection('customPosts');
-        $database->clearDocumentType('customPosts');
-    }
-
-    public function testCustomDocumentTypeWithUpdateDocument(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Create collection
-        $database->createCollection('customUsersUpdate', permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-        ]);
-
-        $database->createAttribute('customUsersUpdate', 'email', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customUsersUpdate', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customUsersUpdate', 'status', Database::VAR_STRING, 50, true);
-
-        // Register custom type
-        $database->setDocumentType('customUsersUpdate', TestUser::class);
-
-        // Create document
-        /** @var TestUser $created */
-        $created = $database->createDocument('customUsersUpdate', new Document([
-            '$id' => ID::unique(),
-            'email' => 'original@example.com',
-            'name' => 'Original Name',
-            'status' => 'active',
-            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
-        ]));
-
-        // Update document
-        /** @var TestUser $updated */
-        $updated = $database->updateDocument('customUsersUpdate', $created->getId(), new Document([
-            '$id' => $created->getId(),
-            'email' => 'updated@example.com',
-            'name' => 'Updated Name',
-            'status' => 'inactive',
-        ]));
-
-        // Verify it's still TestUser and has updated values
-        $this->assertInstanceOf(TestUser::class, $updated);
-        $this->assertEquals('updated@example.com', $updated->getEmail());
-        $this->assertEquals('Updated Name', $updated->getName());
-        $this->assertFalse($updated->isActive());
-
-        // Cleanup
-        $database->deleteCollection('customUsersUpdate');
-        $database->clearDocumentType('customUsersUpdate');
-    }
-
-    public function testDefaultDocumentForUnmappedCollection(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Create collection without custom type
-        $database->createCollection('unmappedCollection', permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-        ]);
-
-        $database->createAttribute('unmappedCollection', 'data', Database::VAR_STRING, 255, true);
-
-        // Create document
-        $created = $database->createDocument('unmappedCollection', new Document([
-            '$id' => ID::unique(),
-            'data' => 'test data',
-            '$permissions' => [Permission::read(Role::any())],
-        ]));
-
-        // Should be regular Document, not custom type
-        $this->assertInstanceOf(Document::class, $created);
-        $this->assertNotInstanceOf(TestUser::class, $created);
-
-        // Cleanup
-        $database->deleteCollection('unmappedCollection');
-    }
-}
diff --git a/tests/e2e/Adapter/Scopes/DocumentTests.php b/tests/e2e/Adapter/Scopes/DocumentTests.php
index cbbe36b8a2..e9c0536162 100644
--- a/tests/e2e/Adapter/Scopes/DocumentTests.php
+++ b/tests/e2e/Adapter/Scopes/DocumentTests.php
@@ -4,8 +4,13 @@
 
 use Exception;
 use PDOException;
+use PHPUnit\Framework\Attributes\Depends;
 use Throwable;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
@@ -17,321 +22,372 @@
 use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Type as TypeException;
-use Utopia\Database\Exception\Unique as UniqueException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Database\SetType;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 
 trait DocumentTests
 {
-    public function testNonUtfChars(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportNonUtfCharacters()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+    private static string $moviesCollection = '';
 
-        $database->createCollection(__FUNCTION__);
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'title', Database::VAR_STRING, 128, true));
+    private static string $documentsCollection = '';
 
-        $nonUtfString = "Hello\x00World\xC3\x28\xFF\xFE\xA0Test\x00End";
+    private static string $incDecCollection = '';
 
-        try {
-            $database->createDocument(__FUNCTION__, new Document([
-                'title' => $nonUtfString,
-            ]));
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertTrue($e instanceof CharacterException);
+    protected function getMoviesCollection(): string
+    {
+        if (self::$moviesCollection === '') {
+            self::$moviesCollection = 'movies_' . uniqid();
         }
+        return self::$moviesCollection;
+    }
 
-        /**
-         * Convert to UTF-8 and replace invalid bytes with empty string
-         */
-        $nonUtfString = mb_convert_encoding($nonUtfString, 'UTF-8', 'UTF-8');
+    protected function getDocumentsCollection(): string
+    {
+        if (self::$documentsCollection === '') {
+            self::$documentsCollection = 'documents_' . uniqid();
+        }
+        return self::$documentsCollection;
+    }
 
-        /**
-         * Remove null bytes
-         */
-        $nonUtfString = str_replace("\0", '', $nonUtfString);
+    protected function getIncDecCollection(): string
+    {
+        if (self::$incDecCollection === '') {
+            self::$incDecCollection = 'increase_decrease_' . uniqid();
+        }
+        return self::$incDecCollection;
+    }
 
-        $document = $database->createDocument(__FUNCTION__, new Document([
-            'title' => $nonUtfString,
-        ]));
+    private static bool $documentsFixtureInit = false;
 
-        $this->assertFalse($document->isEmpty());
-        $this->assertEquals('HelloWorld?(???TestEnd', $document->getAttribute('title'));
-    }
+    private static ?Document $documentsFixtureDoc = null;
 
-    public function testBigintSequence(): void
+    /**
+     * Create the $this->getDocumentsCollection() collection with standard attributes and a test document.
+     * Cached for non-functional mode backward compatibility.
+     */
+    protected function initDocumentsFixture(?string $collection = null): Document
     {
-        /** @var Database $database */
+        $cache = $collection === null;
+        if ($cache && self::$documentsFixtureInit && self::$documentsFixtureDoc !== null) {
+            return clone self::$documentsFixtureDoc;
+        }
+
         $database = $this->getDatabase();
+        $collection ??= $this->getDocumentsCollection();
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: $collection));
 
-        $sequence = 5_000_000_000_000_000;
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
-            $sequence = '01995753-881b-78cf-9506-2cffecf8f227';
+        $database->createAttribute($collection, Attribute::string(key: 'string', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'integer_signed', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'integer_unsigned', size: 4, required: true, signed: false));
+        $database->createAttribute($collection, Attribute::integer(key: 'bigint_signed', size: 8, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'bigint_unsigned', size: 9, required: true, signed: false));
+        $database->createAttribute($collection, Attribute::double(key: 'float_signed', required: true));
+        $database->createAttribute($collection, Attribute::double(key: 'float_unsigned', required: true, signed: false));
+        $database->createAttribute($collection, Attribute::boolean(key: 'boolean', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'colors', size: 32, required: true, array: true));
+        $database->createAttribute($collection, Attribute::string(key: 'empty', size: 32, array: true));
+        $database->createAttribute($collection, Attribute::string(key: 'with-dash', size: 128));
+        $database->createAttribute($collection, Attribute::id(key: 'id'));
+
+        $sequence = '1000000';
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc';
         }
 
-        $document = $database->createDocument(__FUNCTION__, new Document([
-            '$sequence' => (string)$sequence,
+        $document = $database->createDocument($collection, new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
+                Permission::read(Role::user(ID::custom('1'))),
+                Permission::read(Role::user(ID::custom('2'))),
+                Permission::create(Role::any()),
+                Permission::create(Role::user(ID::custom('1x'))),
+                Permission::create(Role::user(ID::custom('2x'))),
+                Permission::update(Role::any()),
+                Permission::update(Role::user(ID::custom('1x'))),
+                Permission::update(Role::user(ID::custom('2x'))),
+                Permission::delete(Role::any()),
+                Permission::delete(Role::user(ID::custom('1x'))),
+                Permission::delete(Role::user(ID::custom('2x'))),
             ],
+            'string' => 'text📝',
+            'integer_signed' => -Database::MAX_INT,
+            'integer_unsigned' => Database::MAX_INT,
+            'bigint_signed' => -Database::MAX_BIG_INT,
+            'bigint_unsigned' => Database::MAX_BIG_INT,
+            'float_signed' => -5.55,
+            'float_unsigned' => 5.55,
+            'boolean' => true,
+            'colors' => ['pink', 'green', 'blue'],
+            'empty' => [],
+            'with-dash' => 'Works',
+            'id' => $sequence,
         ]));
 
-        $this->assertSame((string)$sequence, $document->getSequence());
+        if ($cache) {
+            self::$documentsFixtureInit = true;
+            self::$documentsFixtureDoc = $document;
+        }
 
-        $document = $database->getDocument(__FUNCTION__, $document->getId());
-        $this->assertSame((string)$sequence, $document->getSequence());
+        return $document;
+    }
 
-        $document = $database->findOne(__FUNCTION__, [Query::equal('$sequence', [(string)$sequence])]);
-        $this->assertSame((string)$sequence, $document->getSequence());
+    private static bool $moviesFixtureInit = false;
 
-        /**
-         * Query with int $sequence value (supported by SQL adapters, rejected by MongoDB)
-         */
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_INTEGER) {
-            $this->assertTrue($sequence === 5_000_000_000_000_000);
-            $document = $database->findOne(__FUNCTION__, [Query::equal('$sequence', [$sequence])]);
-            $this->assertSame((string)$sequence, $document->getSequence());
-        }
-    }
+    private static ?string $moviesFixtureSequence = null;
 
-    public function testCreateDocumentWithBigIntType(): void
+    /**
+     * Create the movies collection with standard test data.
+     */
+    protected function initMoviesFixture(): string
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        if (self::$moviesFixtureInit && self::$moviesFixtureSequence !== null) {
+            $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+            $this->getDatabase()->getAuthorization()->addRole('user:x');
+            return self::$moviesFixtureSequence;
+        }
 
-        $database->createCollection(__FUNCTION__);
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'bigint_signed', Database::VAR_BIGINT, 0, true));
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'bigint_unsigned', Database::VAR_BIGINT, 0, true, signed: false));
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
+        $database = $this->getDatabase();
+        $collection = $this->getMoviesCollection();
 
-        $document = $database->createDocument(__FUNCTION__, new Document([
-            '$id' => 'bigint-type-doc',
-            '$permissions' => [Permission::read(Role::any())],
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'bigint_unsigned' => Database::MAX_BIG_INT,
+        $database->createCollection(new Collection(id: $collection, permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users()),
         ]));
 
-        $this->assertIsInt($document->getAttribute('bigint_signed'));
-        $this->assertEquals(-Database::MAX_BIG_INT, $document->getAttribute('bigint_signed'));
-        $this->assertIsInt($document->getAttribute('bigint_unsigned'));
-        $this->assertEquals(Database::MAX_BIG_INT, $document->getAttribute('bigint_unsigned'));
-
-        $results = $database->find(__FUNCTION__, [
-            Query::equal('bigint_unsigned', [Database::MAX_BIG_INT])
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('bigint-type-doc', $results[0]->getId());
-    }
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'director', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'year', required: true));
+        $database->createAttribute($collection, Attribute::double(key: 'price', required: true));
+        $database->createAttribute($collection, Attribute::boolean(key: 'active', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'genres', size: 32, required: true, array: true));
+        $database->createAttribute($collection, Attribute::string(key: 'with-dash', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'nullable', size: 128));
 
-    public function testBigIntScenariosWithFiltering(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::read(Role::user('1')),
+            Permission::read(Role::user('2')),
+            Permission::create(Role::any()),
+            Permission::create(Role::user('1x')),
+            Permission::create(Role::user('2x')),
+            Permission::update(Role::any()),
+            Permission::update(Role::user('1x')),
+            Permission::update(Role::user('2x')),
+            Permission::delete(Role::any()),
+            Permission::delete(Role::user('1x')),
+            Permission::delete(Role::user('2x')),
+        ];
 
-        if (!$database->getAdapter()->getSupportForUnsignedBigInt()) {
-            $this->markTestSkipped('Adapter does not support unsigned bigint');
-        }
+        $document = $database->createDocument($collection, new Document([
+            '$id' => ID::custom('frozen'),
+            '$permissions' => $permissions,
+            'name' => 'Frozen',
+            'director' => 'Chris Buck & Jennifer Lee',
+            'year' => 2013,
+            'price' => 39.50,
+            'active' => true,
+            'genres' => ['animation', 'kids'],
+            'with-dash' => 'Works',
+        ]));
 
-        $collection = 'bigint_scenarios_filters';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'signed_bigint', Database::VAR_BIGINT, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'unsigned_bigint', Database::VAR_BIGINT, 0, true, signed: false));
+        $database->createDocument($collection, new Document([
+            '$permissions' => $permissions,
+            'name' => 'Frozen II',
+            'director' => 'Chris Buck & Jennifer Lee',
+            'year' => 2019,
+            'price' => 39.50,
+            'active' => true,
+            'genres' => ['animation', 'kids'],
+            'with-dash' => 'Works',
+        ]));
 
-        $collectionDoc = $database->getCollection($collection);
-        $this->assertEquals($collection, $collectionDoc->getId());
-        $attributes = $collectionDoc->getAttribute('attributes', []);
-        $signedAttr = null;
-        $unsignedAttr = null;
-        foreach ($attributes as $attribute) {
-            if (($attribute->getAttribute('$id') ?? '') === 'signed_bigint') {
-                $signedAttr = $attribute;
-            }
-            if (($attribute->getAttribute('$id') ?? '') === 'unsigned_bigint') {
-                $unsignedAttr = $attribute;
-            }
-        }
+        $database->createDocument($collection, new Document([
+            '$permissions' => $permissions,
+            'name' => 'Captain America: The First Avenger',
+            'director' => 'Joe Johnston',
+            'year' => 2011,
+            'price' => 25.94,
+            'active' => true,
+            'genres' => ['science fiction', 'action', 'comics'],
+            'with-dash' => 'Works2',
+        ]));
 
-        $this->assertNotNull($signedAttr);
-        $this->assertNotNull($unsignedAttr);
-        $this->assertSame(0, $signedAttr->getAttribute('size'));
-        $this->assertSame(0, $unsignedAttr->getAttribute('size'));
+        $database->createDocument($collection, new Document([
+            '$permissions' => $permissions,
+            'name' => 'Captain Marvel',
+            'director' => 'Anna Boden & Ryan Fleck',
+            'year' => 2019,
+            'price' => 25.99,
+            'active' => true,
+            'genres' => ['science fiction', 'action', 'comics'],
+            'with-dash' => 'Works2',
+        ]));
 
-        // "Out of regular int limit" (32-bit) but valid bigint should still normalize to PHP int.
-        $beyond32Bit = '2147483648';
-        $signedMax = (string)\PHP_INT_MAX;
-        $signedMin = (string)\PHP_INT_MIN;
-        $unsignedValue = '18446744073709551615';
+        $database->createDocument($collection, new Document([
+            '$permissions' => $permissions,
+            'name' => 'Work in Progress',
+            'director' => 'TBD',
+            'year' => 2025,
+            'price' => 0.0,
+            'active' => false,
+            'genres' => [],
+            'with-dash' => 'Works3',
+        ]));
 
-        $document = $database->createDocument($collection, new Document([
-            '$id' => 'bigint-scenarios-doc',
+        $database->createDocument($collection, new Document([
             '$permissions' => [
-                Permission::read(Role::any()),
+                Permission::read(Role::user('x')),
+                Permission::create(Role::any()),
+                Permission::create(Role::user('1x')),
+                Permission::create(Role::user('2x')),
                 Permission::update(Role::any()),
+                Permission::update(Role::user('1x')),
+                Permission::update(Role::user('2x')),
+                Permission::delete(Role::any()),
+                Permission::delete(Role::user('1x')),
+                Permission::delete(Role::user('2x')),
             ],
-            'signed_bigint' => $beyond32Bit,
-            'unsigned_bigint' => $unsignedValue,
-        ]));
-
-        $this->assertIsInt($document->getAttribute('signed_bigint'));
-        $this->assertEquals((int)$beyond32Bit, $document->getAttribute('signed_bigint'));
-
-        // Compare by string representation to stay adapter-agnostic (int/string return type differs).
-        $this->assertEquals($unsignedValue, (string)$document->getAttribute('unsigned_bigint'));
-        $this->assertTrue(\is_string($document->getAttribute('unsigned_bigint')));
-
-        // Read path: fetch document and ensure unsigned bigint round-trips unchanged.
-        $fetchedDocument = $database->getDocument($collection, $document->getId());
-        $this->assertEquals($unsignedValue, (string)$fetchedDocument->getAttribute('unsigned_bigint'));
-
-        // Update path should apply the same normalization for signed bigint numeric strings.
-        $updated = $database->updateDocument($collection, $document->getId(), new Document([
-            'signed_bigint' => $signedMax,
+            'name' => 'Work in Progress 2',
+            'director' => 'TBD',
+            'year' => 2026,
+            'price' => 0.0,
+            'active' => false,
+            'genres' => [],
+            'with-dash' => 'Works3',
+            'nullable' => 'Not null',
         ]));
-        $this->assertIsInt($updated->getAttribute('signed_bigint'));
-        $this->assertEquals((int)$signedMax, $updated->getAttribute('signed_bigint'));
 
-        // Filtering tests: both int and numeric-string filters should match bigint fields.
-        $resultIntFilter = $database->find($collection, [
-            Query::equal('signed_bigint', [(int)$signedMax]),
-        ]);
-        $this->assertCount(1, $resultIntFilter);
-        $this->assertEquals('bigint-scenarios-doc', $resultIntFilter[0]->getId());
+        $sequence = $document->getSequence();
+        $this->assertNotNull($sequence);
+        self::$moviesFixtureInit = true;
+        self::$moviesFixtureSequence = $sequence;
 
-        $resultStringFilter = $database->find($collection, [
-            Query::equal('signed_bigint', [$signedMax]),
-        ]);
-        $this->assertCount(1, $resultStringFilter);
-        $this->assertEquals('bigint-scenarios-doc', $resultStringFilter[0]->getId());
+        return self::$moviesFixtureSequence;
+    }
 
-        $resultUnsignedFilter = $database->find($collection, [
-            Query::equal('unsigned_bigint', [$unsignedValue]),
-        ]);
-        $this->assertCount(1, $resultUnsignedFilter);
-        $this->assertEquals('bigint-scenarios-doc', $resultUnsignedFilter[0]->getId());
+    private static bool $incDecFixtureInit = false;
 
-        // Lower signed boundary as numeric-string should also normalize to int.
-        $updatedMin = $database->updateDocument($collection, $document->getId(), new Document([
-            'signed_bigint' => $signedMin,
-        ]));
-        $this->assertIsInt($updatedMin->getAttribute('signed_bigint'));
-        $this->assertEquals((int)$signedMin, $updatedMin->getAttribute('signed_bigint'));
-    }
+    private static ?Document $incDecFixtureDoc = null;
 
-    public function testWithSingedBigInt(): void
+    /**
+     * Create the increase_decrease collection and perform initial operations.
+     */
+    protected function initIncreaseDecreaseFixture(): Document
     {
-        /** @var Database $database */
+        if (self::$incDecFixtureInit && self::$incDecFixtureDoc !== null) {
+            return self::$incDecFixtureDoc;
+        }
+
         $database = $this->getDatabase();
+        $collection = $this->getIncDecCollection();
 
-        $collection = 'signed_bigint_only';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'signed_bigint', Database::VAR_BIGINT, 0, true));
+        $database->createCollection(new Collection(id: $collection));
 
-        $signedMin = \PHP_INT_MIN;
-        $signedMax = \PHP_INT_MAX;
+        $database->createAttribute($collection, Attribute::integer(key: 'increase', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'decrease', required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'increase_text', required: true));
+        $database->createAttribute($collection, Attribute::double(key: 'increase_float', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'sizes', size: 8, array: true));
 
         $document = $database->createDocument($collection, new Document([
-            '$id' => 'signed-bigint-doc',
+            'increase' => 100,
+            'decrease' => 100,
+            'increase_float' => 100,
+            'increase_text' => 'some text',
+            'sizes' => [10, 20, 30],
             '$permissions' => [
                 Permission::read(Role::any()),
+                Permission::create(Role::any()),
                 Permission::update(Role::any()),
+                Permission::delete(Role::any()),
             ],
-            'signed_bigint' => $signedMax,
         ]));
 
-        $this->assertIsInt($document->getAttribute('signed_bigint'));
-        $this->assertEquals((int)$signedMax, $document->getAttribute('signed_bigint'));
+        $database->increaseDocumentAttribute($collection, $document->getId(), 'increase', 1, 101);
+        $database->decreaseDocumentAttribute($collection, $document->getId(), 'decrease', 1, 98);
+        $database->increaseDocumentAttribute($collection, $document->getId(), 'increase_float', 5.5, 110);
+        $database->decreaseDocumentAttribute($collection, $document->getId(), 'increase_float', 1.1, 100);
 
-        $updated = $database->updateDocument($collection, $document->getId(), new Document([
-            'signed_bigint' => $signedMin,
-        ]));
+        $document = $database->getDocument($collection, $document->getId());
 
-        $this->assertIsInt($updated->getAttribute('signed_bigint'));
-        $this->assertEquals((int)$signedMin, $updated->getAttribute('signed_bigint'));
+        self::$incDecFixtureInit = true;
+        self::$incDecFixtureDoc = $document;
 
-        $results = $database->find($collection, [
-            Query::equal('signed_bigint', [$signedMin]),
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('signed-bigint-doc', $results[0]->getId());
+        return $document;
     }
 
-    public function testCreateDocument(): Document
+    public function testBigintSequence(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('documents');
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
-        $this->assertEquals(true, $database->createAttribute('documents', 'string', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'integer_signed', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'integer_unsigned', Database::VAR_INTEGER, 4, true, signed: false));
-        $this->assertEquals(true, $database->createAttribute('documents', 'bigint_signed', Database::VAR_INTEGER, 8, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'bigint_unsigned', Database::VAR_INTEGER, 9, true, signed: false));
-        $this->assertEquals(true, $database->createAttribute('documents', 'float_signed', Database::VAR_FLOAT, 0, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'float_unsigned', Database::VAR_FLOAT, 0, true, signed: false));
-        $this->assertEquals(true, $database->createAttribute('documents', 'boolean', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'colors', Database::VAR_STRING, 32, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'empty', Database::VAR_STRING, 32, false, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('documents', 'with-dash', Database::VAR_STRING, 128, false, null));
-        $this->assertEquals(true, $database->createAttribute('documents', 'id', Database::VAR_ID, 0, false, null));
-
-        $sequence = '1000000';
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
-            $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc' ;
+        $sequence = 5_000_000_000_000_000;
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01995753-881b-78cf-9506-2cffecf8f227';
         }
 
-        $document = $database->createDocument('documents', new Document([
+        $document = $database->createDocument(__FUNCTION__, new Document([
+            '$sequence' => (string) $sequence,
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::read(Role::user(ID::custom('1'))),
-                Permission::read(Role::user(ID::custom('2'))),
-                Permission::create(Role::any()),
-                Permission::create(Role::user(ID::custom('1x'))),
-                Permission::create(Role::user(ID::custom('2x'))),
-                Permission::update(Role::any()),
-                Permission::update(Role::user(ID::custom('1x'))),
-                Permission::update(Role::user(ID::custom('2x'))),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user(ID::custom('1x'))),
-                Permission::delete(Role::user(ID::custom('2x'))),
             ],
-            'string' => 'text📝',
-            'integer_signed' => -Database::MAX_INT,
-            'integer_unsigned' => Database::MAX_INT,
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'bigint_unsigned' => Database::MAX_BIG_INT,
-            'float_signed' => -5.55,
-            'float_unsigned' => 5.55,
-            'boolean' => true,
-            'colors' => ['pink', 'green', 'blue'],
-            'empty' => [],
-            'with-dash' => 'Works',
-            'id' => $sequence,
         ]));
 
-        $this->assertNotEmpty($document->getId());
-        $this->assertIsString($document->getAttribute('string'));
-        $this->assertEquals('text📝', $document->getAttribute('string')); // Also makes sure an emoji is working
-        $this->assertIsInt($document->getAttribute('integer_signed'));
-        $this->assertEquals(-Database::MAX_INT, $document->getAttribute('integer_signed'));
-        $this->assertIsInt($document->getAttribute('integer_unsigned'));
-        $this->assertEquals(Database::MAX_INT, $document->getAttribute('integer_unsigned'));
-        $this->assertIsInt($document->getAttribute('bigint_signed'));
-        $this->assertEquals(-Database::MAX_BIG_INT, $document->getAttribute('bigint_signed'));
-        $this->assertIsInt($document->getAttribute('bigint_signed'));
-        $this->assertEquals(Database::MAX_BIG_INT, $document->getAttribute('bigint_unsigned'));
-        $this->assertIsFloat($document->getAttribute('float_signed'));
-        $this->assertEquals(-5.55, $document->getAttribute('float_signed'));
-        $this->assertIsFloat($document->getAttribute('float_unsigned'));
+        $this->assertSame((string) $sequence, $document->getSequence());
+
+        $document = $database->getDocument(__FUNCTION__, $document->getId());
+        $this->assertSame((string) $sequence, $document->getSequence());
+
+        $document = $database->findOne(__FUNCTION__, [Query::equal('$sequence', [(string) $sequence])]);
+        $this->assertSame((string) $sequence, $document->getSequence());
+
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Integer->value) {
+            $this->assertTrue($sequence === 5_000_000_000_000_000);
+            $document = $database->findOne(__FUNCTION__, [Query::equal('$sequence', [$sequence])]);
+            $this->assertSame((string) $sequence, $document->getSequence());
+        }
+    }
+
+    public function testCreateDocument(): void
+    {
+        $document = $this->initDocumentsFixture();
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $sequence = '1000000';
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc';
+        }
+
+        $this->assertNotEmpty($document->getId());
+        $this->assertIsString($document->getAttribute('string'));
+        $this->assertEquals('text📝', $document->getAttribute('string')); // Also makes sure an emoji is working
+        $this->assertIsInt($document->getAttribute('integer_signed'));
+        $this->assertEquals(-Database::MAX_INT, $document->getAttribute('integer_signed'));
+        $this->assertIsInt($document->getAttribute('integer_unsigned'));
+        $this->assertEquals(Database::MAX_INT, $document->getAttribute('integer_unsigned'));
+        $this->assertIsInt($document->getAttribute('bigint_signed'));
+        $this->assertEquals(-Database::MAX_BIG_INT, $document->getAttribute('bigint_signed'));
+        $this->assertIsInt($document->getAttribute('bigint_unsigned'));
+        $this->assertEquals(Database::MAX_BIG_INT, $document->getAttribute('bigint_unsigned'));
+        $this->assertIsFloat($document->getAttribute('float_signed'));
+        $this->assertEquals(-5.55, $document->getAttribute('float_signed'));
+        $this->assertIsFloat($document->getAttribute('float_unsigned'));
         $this->assertEquals(5.55, $document->getAttribute('float_unsigned'));
         $this->assertIsBool($document->getAttribute('boolean'));
         $this->assertEquals(true, $document->getAttribute('boolean'));
@@ -342,14 +398,13 @@ public function testCreateDocument(): Document
         $this->assertIsString($document->getAttribute('id'));
         $this->assertEquals($sequence, $document->getAttribute('id'));
 
-
         $sequence = '56000';
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
-            $sequence = '01890dd5-7331-7f3a-9c1b-123456789def' ;
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01890dd5-7331-7f3a-9c1b-123456789def';
         }
 
         // Test create document with manual internal id
-        $manualIdDocument = $database->createDocument('documents', new Document([
+        $manualIdDocument = $database->createDocument($this->getDocumentsCollection(), new Document([
             '$id' => '56000',
             '$sequence' => $sequence,
             '$permissions' => [
@@ -403,7 +458,7 @@ public function testCreateDocument(): Document
         $this->assertEquals('Works', $manualIdDocument->getAttribute('with-dash'));
         $this->assertEquals(null, $manualIdDocument->getAttribute('id'));
 
-        $manualIdDocument = $database->getDocument('documents', '56000');
+        $manualIdDocument = $database->getDocument($this->getDocumentsCollection(), '56000');
 
         $this->assertEquals($sequence, $manualIdDocument->getSequence());
         $this->assertNotEmpty($manualIdDocument->getId());
@@ -429,7 +484,7 @@ public function testCreateDocument(): Document
         $this->assertEquals('Works', $manualIdDocument->getAttribute('with-dash'));
 
         try {
-            $database->createDocument('documents', new Document([
+            $database->createDocument($this->getDocumentsCollection(), new Document([
                 'string' => '',
                 'integer_signed' => 0,
                 'integer_unsigned' => 0,
@@ -443,14 +498,14 @@ public function testCreateDocument(): Document
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertTrue($e instanceof StructureException);
                 $this->assertStringContainsString('Invalid document structure: Attribute "float_unsigned" has invalid type. Value must be a valid range between 0 and', $e->getMessage());
             }
         }
 
         try {
-            $database->createDocument('documents', new Document([
+            $database->createDocument($this->getDocumentsCollection(), new Document([
                 'string' => '',
                 'integer_signed' => 0,
                 'integer_unsigned' => 0,
@@ -464,14 +519,14 @@ public function testCreateDocument(): Document
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertTrue($e instanceof StructureException);
                 $this->assertEquals('Invalid document structure: Attribute "bigint_unsigned" has invalid type. Value must be a valid range between 0 and 9,223,372,036,854,775,807', $e->getMessage());
             }
         }
 
         try {
-            $database->createDocument('documents', new Document([
+            $database->createDocument($this->getDocumentsCollection(), new Document([
                 '$sequence' => '0',
                 '$permissions' => [],
                 'string' => '',
@@ -488,7 +543,7 @@ public function testCreateDocument(): Document
             ]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
                 $this->assertTrue($e instanceof StructureException);
                 $this->assertEquals('Invalid document structure: Attribute "$sequence" has invalid type. Invalid sequence value', $e->getMessage());
             }
@@ -497,8 +552,7 @@ public function testCreateDocument(): Document
         /**
          * Insert ID attribute with NULL
          */
-
-        $documentIdNull = $database->createDocument('documents', new Document([
+        $documentIdNull = $database->createDocument($this->getDocumentsCollection(), new Document([
             'id' => null,
             '$permissions' => [Permission::read(Role::any())],
             'string' => '',
@@ -516,25 +570,25 @@ public function testCreateDocument(): Document
         $this->assertNotEmpty($documentIdNull->getSequence());
         $this->assertNull($documentIdNull->getAttribute('id'));
 
-        $documentIdNull = $database->getDocument('documents', $documentIdNull->getId());
+        $documentIdNull = $database->getDocument($this->getDocumentsCollection(), $documentIdNull->getId());
         $this->assertNotEmpty($documentIdNull->getId());
         $this->assertNull($documentIdNull->getAttribute('id'));
 
-        $documentIdNull = $database->findOne('documents', [
-            query::isNull('id')
+        $documentIdNull = $database->findOne($this->getDocumentsCollection(), [
+            query::isNull('id'),
         ]);
         $this->assertNotEmpty($documentIdNull->getId());
         $this->assertNull($documentIdNull->getAttribute('id'));
 
         $sequence = '0';
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
             $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc';
         }
 
         /**
          * Insert ID attribute with '0'
          */
-        $documentId0 = $database->createDocument('documents', new Document([
+        $documentId0 = $database->createDocument($this->getDocumentsCollection(), new Document([
             'id' => $sequence,
             '$permissions' => [Permission::read(Role::any())],
             'string' => '',
@@ -554,49 +608,17 @@ public function testCreateDocument(): Document
         $this->assertIsString($documentId0->getAttribute('id'));
         $this->assertEquals($sequence, $documentId0->getAttribute('id'));
 
-        $documentId0 = $database->getDocument('documents', $documentId0->getId());
+        $documentId0 = $database->getDocument($this->getDocumentsCollection(), $documentId0->getId());
         $this->assertNotEmpty($documentId0->getSequence());
         $this->assertIsString($documentId0->getAttribute('id'));
         $this->assertEquals($sequence, $documentId0->getAttribute('id'));
 
-        $documentId0 = $database->findOne('documents', [
-            query::equal('id', [$sequence])
+        $documentId0 = $database->findOne($this->getDocumentsCollection(), [
+            query::equal('id', [$sequence]),
         ]);
         $this->assertNotEmpty($documentId0->getSequence());
         $this->assertIsString($documentId0->getAttribute('id'));
         $this->assertEquals($sequence, $documentId0->getAttribute('id'));
-
-
-        return $document;
-    }
-
-    public function testCreateDocumentNumericalId(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection('numericalIds');
-
-        $this->assertEquals(true, $database->createAttribute('numericalIds', 'name', Database::VAR_STRING, 128, true));
-
-        // Test creating a document with an entirely numerical ID
-        $numericalIdDocument = $database->createDocument('numericalIds', new Document([
-            '$id' => '123456789',
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'name' => 'Test Document with Numerical ID',
-        ]));
-
-        $this->assertIsString($numericalIdDocument->getId());
-        $this->assertEquals('123456789', $numericalIdDocument->getId());
-        $this->assertEquals('Test Document with Numerical ID', $numericalIdDocument->getAttribute('name'));
-
-        // Verify we can retrieve the document
-        $retrievedDocument = $database->getDocument('numericalIds', '123456789');
-        $this->assertIsString($retrievedDocument->getId());
-        $this->assertEquals('123456789', $retrievedDocument->getId());
-        $this->assertEquals('Test Document with Numerical ID', $retrievedDocument->getAttribute('name'));
     }
 
     public function testCreateDocuments(): void
@@ -607,11 +629,11 @@ public function testCreateDocuments(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection($collection);
+        $database->createCollection(new Collection(id: $collection));
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'integer', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'bigint', Database::VAR_INTEGER, 8, true));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'integer', required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'bigint', size: 8, required: true)));
 
         // Create an array of documents with random attributes. Don't use the createDocument function
         $documents = [];
@@ -649,7 +671,7 @@ public function testCreateDocuments(): void
         }
 
         $documents = $database->find($collection, [
-            Query::orderAsc()
+            Query::orderAsc(),
         ]);
 
         $this->assertEquals($count, \count($documents));
@@ -673,24 +695,25 @@ public function testCacheEmptyDocument(): void
 
         // The Redis adapter runs with a no-op cache (reads hit Redis directly),
         // so there is no cache layer to inspect.
-        if (!$database->getAdapter()->getSupportForCaching()) {
+        if (!$database->getAdapter()->supports(Capability::Caching)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collection = 'cacheEmpty';
-        $database->createCollection($collection, permissions: [
+        $database->createCollection(new Collection(id: $collection, permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ], documentSecurity: false);
-        $this->assertEquals(true, $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, false));
+        ], documentSecurity: false));
+        $this->assertTrue($database->createAttribute($collection, Attribute::string(key: 'name', size: 128)));
 
         // A read of a missing id records a negative ("not found") marker so
         // repeated lookups don't keep hitting the adapter.
         $this->assertTrue($database->getDocument($collection, 'ghost')->isEmpty());
 
-        [, $documentKey, $hashKey] = $database->getCacheKeys($collection, 'ghost');
-        $cached = $cache->load($documentKey, Database::TTL, $hashKey);
+        [$collectionKey] = $database->getCacheKeys($collection, 'ghost');
+        $epoch = $cache->load($collectionKey.'#epoch', Database::TTL);
+        $cached = $this->loadDocumentPointCache($database, $collection, 'ghost');
         $this->assertIsArray($cached);
         $this->assertArrayHasKey('$empty', $cached); // Database::CACHE_EMPTY_MARKER
 
@@ -701,7 +724,8 @@ public function testCacheEmptyDocument(): void
             'name' => 'real',
         ]));
 
-        $this->assertFalse($cache->load($documentKey, Database::TTL, $hashKey));
+        $this->assertNotSame($epoch, $cache->load($collectionKey.'#epoch', Database::TTL));
+        $this->assertFalse($this->loadDocumentPointCache($database, $collection, 'ghost'));
 
         $document = $database->getDocument($collection, 'ghost');
         $this->assertFalse($document->isEmpty());
@@ -709,8 +733,9 @@ public function testCacheEmptyDocument(): void
 
         // Same guarantee through the batch create path.
         $this->assertTrue($database->getDocument($collection, 'batch')->isEmpty());
-        [, $batchKey, $batchHash] = $database->getCacheKeys($collection, 'batch');
-        $cached = $cache->load($batchKey, Database::TTL, $batchHash);
+        [$batchCollectionKey] = $database->getCacheKeys($collection, 'batch');
+        $batchEpoch = $cache->load($batchCollectionKey.'#epoch', Database::TTL);
+        $cached = $this->loadDocumentPointCache($database, $collection, 'batch');
         $this->assertIsArray($cached);
         $this->assertArrayHasKey('$empty', $cached);
 
@@ -722,13 +747,13 @@ public function testCacheEmptyDocument(): void
             ]),
         ]);
 
-        $this->assertFalse($cache->load($batchKey, Database::TTL, $batchHash));
+        $this->assertNotSame($batchEpoch, $cache->load($batchCollectionKey.'#epoch', Database::TTL));
+        $this->assertFalse($this->loadDocumentPointCache($database, $collection, 'batch'));
         $this->assertEquals('batched', $database->getDocument($collection, 'batch')->getAttribute('name'));
 
         // A locking read must never publish anything to the cache.
         $this->assertTrue($database->getDocument($collection, 'phantom', forUpdate: true)->isEmpty());
-        [, $phantomKey, $phantomHash] = $database->getCacheKeys($collection, 'phantom');
-        $this->assertFalse($cache->load($phantomKey, Database::TTL, $phantomHash));
+        $this->assertFalse($this->loadDocumentPointCache($database, $collection, 'phantom'));
     }
 
     public function testCacheEmptyDocumentSelect(): void
@@ -739,23 +764,23 @@ public function testCacheEmptyDocumentSelect(): void
 
         // The Redis adapter runs with a no-op cache (reads hit Redis directly),
         // so there is no cache layer to inspect.
-        if (!$database->getAdapter()->getSupportForCaching()) {
+        if (!$database->getAdapter()->supports(Capability::Caching)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collection = 'cacheEmptySelect';
-        $database->createCollection($collection, permissions: [
+        $database->createCollection(new Collection(id: $collection, permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, false));
+        $this->assertTrue($database->createAttribute($collection, Attribute::string(key: 'name', size: 128)));
 
         // The document key is select-independent, but the hashKey is not: a
         // projection is folded into it. So a projected read and a plain read of
         // the same missing id are cached under different slots of the same key.
-        [, $documentKey, $plainHash] = $database->getCacheKeys($collection, 'ghost');
+        [$collectionKey, , $plainHash] = $database->getCacheKeys($collection, 'ghost');
 
         // validateSelections() appends the internal attributes to the user
         // selection before it forms the key; mirror that set to address the
@@ -766,67 +791,63 @@ public function testCacheEmptyDocumentSelect(): void
 
         // Projected read caches its marker under the projected slot only.
         $this->assertTrue($database->getDocument($collection, 'ghost', [Query::select(['name'])])->isEmpty());
-        $cached = $cache->load($documentKey, Database::TTL, $selectHash);
+        $cached = $this->loadDocumentPointCache($database, $collection, 'ghost', ...$selects);
         $this->assertIsArray($cached);
         $this->assertArrayHasKey('$empty', $cached);
         $this->assertFalse(
-            $cache->load($documentKey, Database::TTL, $plainHash),
+            $this->loadDocumentPointCache($database, $collection, 'ghost'),
             'A projected read must not populate the no-projection cache slot'
         );
 
         // Plain read fills the plain slot with its own marker. Both slots of the
         // document key now hold an "empty" marker.
         $this->assertTrue($database->getDocument($collection, 'ghost')->isEmpty());
-        $cached = $cache->load($documentKey, Database::TTL, $plainHash);
-        $this->assertIsArray($cached);
-        $this->assertArrayHasKey('$empty', $cached);
+        $plainCached = $this->loadDocumentPointCache($database, $collection, 'ghost');
+        $this->assertIsArray($plainCached);
+        $this->assertArrayHasKey('$empty', $plainCached);
 
-        // Inserting the id purges the whole document key, so BOTH slots clear.
+        $epoch = $cache->load($collectionKey.'#epoch', Database::TTL);
+
+        // Inserting the id advances the collection epoch, so both active slots clear.
         $database->createDocument($collection, new Document([
             '$id' => 'ghost',
             '$permissions' => [Permission::read(Role::any())],
             'name' => 'real',
         ]));
 
-        $this->assertFalse($cache->load($documentKey, Database::TTL, $plainHash));
-        $this->assertFalse($cache->load($documentKey, Database::TTL, $selectHash));
+        $this->assertNotSame($epoch, $cache->load($collectionKey.'#epoch', Database::TTL));
+        $this->assertFalse($this->loadDocumentPointCache($database, $collection, 'ghost'));
+        $this->assertFalse($this->loadDocumentPointCache($database, $collection, 'ghost', ...$selects));
     }
 
     public function testCacheEmptyGetCollection(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        $cache = $database->getCache();
-
         // The Redis adapter runs with a no-op cache (reads hit Redis directly),
         // so there is no cache layer to inspect.
-        if (!$database->getAdapter()->getSupportForCaching()) {
+        if (!$database->getAdapter()->supports(Capability::Caching)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'cacheEmptyCollection';
 
-        // getCollection() reads getDocument(METADATA, id) under the hood, so a
-        // lookup of a non-existent collection negatively caches its absence
-        // under the metadata key.
+        // Metadata point caching is disabled, so a missing collection must not
+        // leave a negative marker behind.
         $this->assertTrue($database->getCollection($collectionId)->isEmpty());
-
-        [, $metaKey, $metaHash] = $database->getCacheKeys(Database::METADATA, $collectionId);
-        $cached = $cache->load($metaKey, Database::TTL, $metaHash);
-        $this->assertIsArray($cached);
-        $this->assertArrayHasKey('$empty', $cached);
+        $this->assertFalse($this->loadDocumentPointCache($database, Database::METADATA, $collectionId));
 
         // createCollection() writes the metadata row via createDocument(METADATA),
         // which must purge that marker — otherwise the collection would keep
         // reading back as "not found".
-        $collection = $database->createCollection($collectionId, permissions: [
+        $collection = $database->createCollection(new Collection(id: $collectionId, permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
         $this->assertFalse($collection->isEmpty());
 
-        $this->assertFalse($cache->load($metaKey, Database::TTL, $metaHash));
+        $this->assertFalse($this->loadDocumentPointCache($database, Database::METADATA, $collectionId));
 
         $fetched = $database->getCollection($collectionId);
         $this->assertFalse($fetched->isEmpty());
@@ -836,7 +857,7 @@ public function testCacheEmptyGetCollection(): void
         // marker was genuinely invalidated: a lingering "not found" would make
         // createCollection's own existence check pass and wrongly proceed.
         try {
-            $database->createCollection($collectionId);
+            $database->createCollection(new Collection(id: $collectionId));
             $this->fail('Expected DuplicateException when recreating an existing collection');
         } catch (DuplicateException) {
             // expected
@@ -848,11 +869,9 @@ public function testCacheEmptyDocumentSecurity(): void
         /** @var Database $database */
         $database = $this->getDatabase();
         $auth = $database->getAuthorization();
-        $cache = $database->getCache();
-
         // The Redis adapter runs with a no-op cache (reads hit Redis directly),
         // so there is no cache layer to inspect.
-        if (!$database->getAdapter()->getSupportForCaching()) {
+        if (!$database->getAdapter()->supports(Capability::Caching)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -862,8 +881,8 @@ public function testCacheEmptyDocumentSecurity(): void
         // Document-level security with no collection-wide read: access is
         // decided per document.
         $auth->skip(function () use ($database, $collection) {
-            $database->createCollection($collection, permissions: [], documentSecurity: true);
-            $this->assertEquals(true, $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, false));
+            $database->createCollection(new Collection(id: $collection));
+            $this->assertTrue($database->createAttribute($collection, Attribute::string(key: 'name', size: 128)));
             $database->createDocument($collection, new Document([
                 '$id' => 'secret',
                 '$permissions' => [
@@ -882,8 +901,7 @@ public function testCacheEmptyDocumentSecurity(): void
 
             $this->assertTrue($database->getDocument($collection, 'secret')->isEmpty());
 
-            [, $documentKey, $hashKey] = $database->getCacheKeys($collection, 'secret');
-            $cached = $cache->load($documentKey, Database::TTL, $hashKey);
+            $cached = $this->loadDocumentPointCache($database, $collection, 'secret');
             $this->assertFalse(
                 \is_array($cached) && isset($cached['$empty']),
                 'A permission-denied read of an existing document must not populate the negative cache'
@@ -901,8 +919,7 @@ public function testCacheEmptyDocumentSecurity(): void
             // A genuinely missing id is user-independent, so it is still safe to
             // cache as empty even under document security.
             $this->assertTrue($database->getDocument($collection, 'ghost')->isEmpty());
-            [, $ghostKey, $ghostHash] = $database->getCacheKeys($collection, 'ghost');
-            $ghostCached = $cache->load($ghostKey, Database::TTL, $ghostHash);
+            $ghostCached = $this->loadDocumentPointCache($database, $collection, 'ghost');
             $this->assertIsArray($ghostCached);
             $this->assertArrayHasKey('$empty', $ghostCached);
         } finally {
@@ -916,19 +933,19 @@ public function testCreateDocumentsWithAutoIncrement(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, Attribute::string(key: 'string', size: 128, required: true)));
 
         /** @var array<Document> $documents */
         $documents = [];
         $offset = 1000000;
         for ($i = $offset; $i <= ($offset + 10); $i++) {
-            $sequence = (string)$i;
-            if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
+            $sequence = (string) $i;
+            if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
                 // Replace last 6 digits with $i to make it unique
-                $suffix = str_pad(substr((string)$i, -6), 6, '0', STR_PAD_LEFT);
-                $sequence = '01890dd5-7331-7f3a-9c1b-123456' . $suffix;
+                $suffix = str_pad(substr((string) $i, -6), 6, '0', STR_PAD_LEFT);
+                $sequence = '01890dd5-7331-7f3a-9c1b-123456'.$suffix;
             }
 
             $hash[$i] = $sequence;
@@ -949,7 +966,7 @@ public function testCreateDocumentsWithAutoIncrement(): void
         $this->assertEquals($count, \count($documents));
 
         $documents = $database->find(__FUNCTION__, [
-            Query::orderAsc()
+            Query::orderAsc(),
         ]);
 
         foreach ($documents as $index => $document) {
@@ -966,12 +983,12 @@ public function testCreateDocumentsWithDifferentAttributes(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection($collection);
+        $database->createCollection(new Collection(id: $collection));
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'integer', Database::VAR_INTEGER, 0, false));
-        $this->assertEquals(true, $database->createAttribute($collection, 'bigint', Database::VAR_INTEGER, 8, false));
-        $this->assertEquals(true, $database->createAttribute($collection, 'string_default', Database::VAR_STRING, 128, false, 'default'));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'integer')));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'bigint', size: 8)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string_default', size: 128, default: 'default')));
 
         $documents = [
             new Document([
@@ -1031,88 +1048,21 @@ public function testCreateDocumentsWithDifferentAttributes(): void
         $database->deleteCollection($collection);
     }
 
-    public function testSkipPermissions(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'number', Database::VAR_INTEGER, 0, false);
-
-        $data = [];
-        for ($i = 1; $i <= 10; $i++) {
-            $data[] = [
-                '$id' => "$i",
-                'number' => $i,
-            ];
-        }
-
-        $documents = array_map(fn ($d) => new Document($d), $data);
-
-        $results = [];
-        $count = $database->createDocuments(__FUNCTION__, $documents, onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-        });
-
-        $this->assertEquals($count, \count($results));
-        $this->assertEquals(10, \count($results));
-
-        /**
-         * Update 1 row
-         */
-        $data[\array_key_last($data)]['number'] = 100;
-
-        /**
-         * Add 1 row
-         */
-        $data[] = [
-            '$id' => "101",
-            'number' => 101,
-        ];
-
-        $documents = array_map(fn ($d) => new Document($d), $data);
-
-        $this->getDatabase()->getAuthorization()->disable();
-
-        $results = [];
-        $count = $database->upsertDocuments(
-            __FUNCTION__,
-            $documents,
-            onNext: function ($doc) use (&$results) {
-                $results[] = $doc;
-            }
-        );
-
-        $this->getDatabase()->getAuthorization()->reset();
-
-        $this->assertEquals(2, \count($results));
-        $this->assertEquals(2, $count);
-
-        foreach ($results as $result) {
-            $this->assertArrayHasKey('$permissions', $result);
-            $this->assertEquals([], $result->getAttribute('$permissions'));
-        }
-    }
-
     public function testUpsertDocuments(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true);
-        $database->createAttribute(__FUNCTION__, 'integer', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute(__FUNCTION__, 'bigint', Database::VAR_INTEGER, 8, true);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'string', size: 128, required: true));
+        $database->createAttribute(__FUNCTION__, Attribute::integer(key: 'integer', required: true));
+        $database->createAttribute(__FUNCTION__, Attribute::integer(key: 'bigint', size: 8, required: true));
 
         $documents = [
             new Document([
@@ -1225,16 +1175,16 @@ public function testTextByteTruncationCreate(): void
 
         // Byte-capacity validation relies on attribute metadata, which
         // schemaless adapters don't store, so there is nothing to enforce.
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
         // A `text` attribute at its maximum allowed size. On MySQL/MariaDB this
         // maps to a TEXT column, which is limited to 65,535 *bytes*.
-        $database->createAttribute(__FUNCTION__, 'text', Database::VAR_TEXT, 65535, false);
+        $database->createAttribute(__FUNCTION__, Attribute::text(key: 'text', size: Database::MAX_TEXT_BYTES));
 
         // The Structure validator caps a TEXT column at its 65,535-byte capacity,
         // measuring the value's actual byte length. A 20,000-char emoji value is
@@ -1269,13 +1219,13 @@ public function testTextByteTruncationValid(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'text', Database::VAR_TEXT, 65535, false);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::text(key: 'text', size: Database::MAX_TEXT_BYTES));
 
         // A value that fills the column's full byte capacity is stored and
         // round-trips intact. 65,535 ASCII chars are exactly 65,535 bytes, so
@@ -1304,13 +1254,13 @@ public function testTextByteTruncationUpdate(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'text', Database::VAR_TEXT, 65535, false);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::text(key: 'text', size: Database::MAX_TEXT_BYTES));
 
         $document = new Document([
             '$id' => 'first',
@@ -1342,14 +1292,15 @@ public function testUpsertDocumentsInc(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, false);
-        $database->createAttribute(__FUNCTION__, 'integer', Database::VAR_INTEGER, 0, false);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'string', size: 128));
+        $database->createAttribute(__FUNCTION__, Attribute::integer(key: 'integer'));
 
         $documents = [
             new Document([
@@ -1414,13 +1365,14 @@ public function testUpsertDocumentsPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'string', size: 128, required: true));
 
         $document = new Document([
             '$id' => 'first',
@@ -1498,7753 +1450,6892 @@ public function testUpsertDocumentsPermissions(): void
         $this->assertEquals($newPermissions, $document->getPermissions());
     }
 
-    public function testUpsertDocumentsAttributeMismatch(): void
+    public function testUpsertMixedPermissionDelta(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        $db = $this->getDatabase();
+        if (! ($db->getAdapter()->hasFeature(Feature\Upserts::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection(__FUNCTION__, permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ], documentSecurity: false);
-        $database->createAttribute(__FUNCTION__, 'first', Database::VAR_STRING, 128, true);
-        $database->createAttribute(__FUNCTION__, 'last', Database::VAR_STRING, 128, false);
+        $db->createCollection(new Collection(id: __FUNCTION__));
+        $db->createAttribute(__FUNCTION__, Attribute::integer(key: 'v', required: true));
 
-        $existingDocument = $database->createDocument(__FUNCTION__, new Document([
-            '$id' => 'first',
-            'first' => 'first',
-            'last' => 'last',
+        $d1 = $db->createDocument(__FUNCTION__, new Document([
+            '$id' => 'a',
+            'v' => 0,
+            '$permissions' => [
+                Permission::update(Role::any()),
+            ],
+        ]));
+        $d2 = $db->createDocument(__FUNCTION__, new Document([
+            '$id' => 'b',
+            'v' => 0,
+            '$permissions' => [
+                Permission::update(Role::any()),
+            ],
         ]));
 
-        $newDocument = new Document([
-            '$id' => 'second',
-            'first' => 'second',
+        // d1 adds write, d2 removes update
+        $d1->setAttribute('$permissions', [
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
         ]);
-
-        // Ensure missing optionals on new document is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $existingDocument->setAttribute('first', 'updated'),
-            $newDocument,
+        $d2->setAttribute('$permissions', [
+            Permission::read(Role::any()),
         ]);
 
-        $this->assertEquals(2, $docs);
-        $this->assertEquals('updated', $existingDocument->getAttribute('first'));
-        $this->assertEquals('last', $existingDocument->getAttribute('last'));
-        $this->assertEquals('second', $newDocument->getAttribute('first'));
-        $this->assertEquals('', $newDocument->getAttribute('last'));
+        $db->upsertDocuments(__FUNCTION__, [$d1, $d2]);
+
+        $this->assertEquals([
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+        ], $db->getDocument(__FUNCTION__, 'a')->getPermissions());
+
+        $this->assertEquals([
+            Permission::read(Role::any()),
+        ], $db->getDocument(__FUNCTION__, 'b')->getPermissions());
+    }
+
+    public function testGetDocument(): void
+    {
+        $document = $this->initDocumentsFixture();
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $document = $database->getDocument($this->getDocumentsCollection(), $document->getId());
+
+        $this->assertNotEmpty($document->getId());
+        $this->assertIsString($document->getAttribute('string'));
+        $this->assertEquals('text📝', $document->getAttribute('string'));
+        $this->assertIsInt($document->getAttribute('integer_signed'));
+        $this->assertEquals(-Database::MAX_INT, $document->getAttribute('integer_signed'));
+        $this->assertIsFloat($document->getAttribute('float_signed'));
+        $this->assertEquals(-5.55, $document->getAttribute('float_signed'));
+        $this->assertIsFloat($document->getAttribute('float_unsigned'));
+        $this->assertEquals(5.55, $document->getAttribute('float_unsigned'));
+        $this->assertIsBool($document->getAttribute('boolean'));
+        $this->assertEquals(true, $document->getAttribute('boolean'));
+        $this->assertIsArray($document->getAttribute('colors'));
+        $this->assertEquals(['pink', 'green', 'blue'], $document->getAttribute('colors'));
+        $this->assertEquals('Works', $document->getAttribute('with-dash'));
+    }
+
+    public function testFind(): void
+    {
+        $this->initMoviesFixture();
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         try {
-            $database->upsertDocuments(__FUNCTION__, [
-                $existingDocument->removeAttribute('first'),
-                $newDocument
-            ]);
+            $database->createDocument($this->getMoviesCollection(), new Document(['$id' => ['id_as_array']]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
-                $this->assertTrue($e instanceof StructureException, $e->getMessage());
-            }
+            $this->assertEquals('$id must be of type string', $e->getMessage());
+            $this->assertInstanceOf(StructureException::class, $e);
         }
+    }
 
-        // Ensure missing optionals on existing document is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $existingDocument
-                ->setAttribute('first', 'first')
-                ->removeAttribute('last'),
-            $newDocument
-                ->setAttribute('last', 'last')
+    public function testFindCheckInteger(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        /**
+         * Query with dash attribute
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('with-dash', ['Works']),
         ]);
 
-        $this->assertEquals(2, $docs);
-        $this->assertEquals('first', $existingDocument->getAttribute('first'));
-        $this->assertEquals('last', $existingDocument->getAttribute('last'));
-        $this->assertEquals('second', $newDocument->getAttribute('first'));
-        $this->assertEquals('last', $newDocument->getAttribute('last'));
+        $this->assertEquals(2, count($documents));
 
-        // Ensure set null on existing document is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $existingDocument
-                ->setAttribute('first', 'first')
-                ->setAttribute('last', null),
-            $newDocument
-                ->setAttribute('last', 'last')
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('with-dash', ['Works2', 'Works3']),
         ]);
 
-        $this->assertEquals(1, $docs);
-        $this->assertEquals('first', $existingDocument->getAttribute('first'));
-        $this->assertEquals(null, $existingDocument->getAttribute('last'));
-        $this->assertEquals('second', $newDocument->getAttribute('first'));
-        $this->assertEquals('last', $newDocument->getAttribute('last'));
+        $this->assertEquals(4, count($documents));
 
-        $doc3 = new Document([
-            '$id' => 'third',
-            'last' => 'last',
-            'first' => 'third',
+        /**
+         * Check an Integer condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('year', [2019]),
         ]);
 
-        $doc4 = new Document([
-            '$id' => 'fourth',
-            'first' => 'fourth',
-            'last' => 'last',
-        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals('Frozen II', $documents[0]['name']);
+        $this->assertEquals('Captain Marvel', $documents[1]['name']);
+    }
 
-        // Ensure mismatch of attribute orders is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $doc3,
-            $doc4
+    public function testFindBoolean(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        /**
+         * Boolean condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('active', [true]),
         ]);
 
-        $this->assertEquals(2, $docs);
-        $this->assertEquals('third', $doc3->getAttribute('first'));
-        $this->assertEquals('last', $doc3->getAttribute('last'));
-        $this->assertEquals('fourth', $doc4->getAttribute('first'));
-        $this->assertEquals('last', $doc4->getAttribute('last'));
+        $this->assertEquals(4, count($documents));
+    }
 
-        $doc3 = $database->getDocument(__FUNCTION__, 'third');
-        $doc4 = $database->getDocument(__FUNCTION__, 'fourth');
+    public function testFindFloat(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals('third', $doc3->getAttribute('first'));
-        $this->assertEquals('last', $doc3->getAttribute('last'));
-        $this->assertEquals('fourth', $doc4->getAttribute('first'));
-        $this->assertEquals('last', $doc4->getAttribute('last'));
+        /**
+         * Float condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::lessThan('price', 26.00),
+            Query::greaterThan('price', 25.98),
+        ]);
+
+        $this->assertEquals(1, count($documents));
     }
 
-    public function testUpsertDocumentsNoop(): void
+    public function testFindContains(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForUpserts()) {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (! $database->getAdapter()->supports(Capability::QueryContains)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->createCollection(__FUNCTION__);
-        $this->getDatabase()->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true);
+        $this->initMoviesFixture();
 
-        $document = new Document([
-            '$id' => 'first',
-            'string' => 'text📝',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['comics']),
         ]);
 
-        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
-        $this->assertEquals(1, $count);
+        $this->assertEquals(2, count($documents));
 
-        // No changes, should return 0
-        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
-        $this->assertEquals(0, $count);
-    }
+        /**
+         * Array contains OR condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['comics', 'kids']),
+        ]);
 
-    public function testUpsertDuplicateIds(): void
-    {
-        $db = $this->getDatabase();
-        if (!$db->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $this->assertEquals(4, count($documents));
 
-        $db->createCollection(__FUNCTION__);
-        $db->createAttribute(__FUNCTION__, 'num', Database::VAR_INTEGER, 0, true);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['non-existent']),
+        ]);
 
-        $doc1 = new Document(['$id' => 'dup', 'num' => 1]);
-        $doc2 = new Document(['$id' => 'dup', 'num' => 2]);
+        $this->assertEquals(0, count($documents));
 
         try {
-            $db->upsertDocuments(__FUNCTION__, [$doc1, $doc2]);
+            $database->find($this->getMoviesCollection(), [
+                Query::contains('price', [10.5]),
+            ]);
             $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e, $e->getMessage());
+        } catch (Throwable $e) {
+            $this->assertEquals('Invalid query: Cannot query contains on attribute "price" because it is not an array, string, or object.', $e->getMessage());
+            $this->assertTrue($e instanceof DatabaseException);
         }
     }
 
-    public function testUpsertMixedPermissionDelta(): void
+    public function testFindFulltext(): void
     {
-        $db = $this->getDatabase();
-        if (!$db->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $db->createCollection(__FUNCTION__);
-        $db->createAttribute(__FUNCTION__, 'v', Database::VAR_INTEGER, 0, true);
+        /**
+         * Fulltext search
+         */
+        if ($this->getDatabase()->getAdapter()->supports(Capability::Fulltext)) {
+            $success = $database->createIndex($this->getMoviesCollection(), Index::fullText(key: 'name', attributes: ['name']));
+            $this->assertEquals(true, $success);
 
-        $d1 = $db->createDocument(__FUNCTION__, new Document([
-            '$id' => 'a',
-            'v' => 0,
-            '$permissions' => [
-                Permission::update(Role::any())
-            ]
-        ]));
-        $d2 = $db->createDocument(__FUNCTION__, new Document([
-            '$id' => 'b',
-            'v' => 0,
-            '$permissions' => [
-                Permission::update(Role::any())
-            ]
-        ]));
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::search('name', 'captain'),
+            ]);
 
-        // d1 adds write, d2 removes update
-        $d1->setAttribute('$permissions', [
-            Permission::read(Role::any()),
-            Permission::update(Role::any())
-        ]);
-        $d2->setAttribute('$permissions', [
-            Permission::read(Role::any())
-        ]);
+            $this->assertEquals(2, count($documents));
 
-        $db->upsertDocuments(__FUNCTION__, [$d1, $d2]);
+            /**
+             * Fulltext search (wildcard)
+             */
 
-        $this->assertEquals([
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-        ], $db->getDocument(__FUNCTION__, 'a')->getPermissions());
+            // TODO: Looks like the MongoDB implementation is a bit more complex, skipping that for now.
+            // TODO: I think this needs a changes? how do we distinguish between regular full text and wildcard?
 
-        $this->assertEquals([
-            Permission::read(Role::any()),
-        ], $db->getDocument(__FUNCTION__, 'b')->getPermissions());
+            if ($this->getDatabase()->getAdapter()->supports(Capability::FulltextWildcard)) {
+                $documents = $database->find($this->getMoviesCollection(), [
+                    Query::search('name', 'cap'),
+                ]);
+
+                $this->assertEquals(2, count($documents));
+            }
+        }
+
+        $this->assertEquals(true, true); // Test must do an assertion
     }
 
-    public function testPreserveSequenceUpsert(): void
+    public function testFindFulltextSpecialChars(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! $database->getAdapter()->supports(Capability::Fulltext)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $collectionName = 'preserve_sequence_upsert';
-
-        $database->createCollection($collectionName);
+        $collection = 'full_text';
+        $database->createCollection(new Collection(id: $collection, permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users()),
+        ]));
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $database->createAttribute($collectionName, 'name', Database::VAR_STRING, 128, true);
-        }
+        $this->assertTrue($database->createAttribute($collection, Attribute::string(key: 'ft', size: 128, required: true)));
+        $this->assertTrue($database->createIndex($collection, Index::fullText(key: 'ft-index', attributes: ['ft'])));
 
-        // Create initial documents
-        $doc1 = $database->createDocument($collectionName, new Document([
-            '$id' => 'doc1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'Alice',
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'ft' => 'Alf: chapter_4@nasa.com',
         ]));
 
-        $doc2 = $database->createDocument($collectionName, new Document([
-            '$id' => 'doc2',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'Bob',
+        $documents = $database->find($collection, [
+            Query::search('ft', 'chapter_4'),
+        ]);
+        $this->assertEquals(1, count($documents));
+
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'ft' => 'al@ba.io +-*)(<>~',
         ]));
 
-        $originalSeq1 = $doc1->getSequence();
-        $originalSeq2 = $doc2->getSequence();
+        $documents = $database->find($collection, [
+            Query::search('ft', 'al@ba.io'), // tokenized as: al ba io*
+        ]);
 
-        $this->assertNotEmpty($originalSeq1);
-        $this->assertNotEmpty($originalSeq2);
+        if ($database->getAdapter()->supports(Capability::FulltextWildcard)) {
+            $this->assertEquals(0, count($documents));
+        } else {
+            $this->assertEquals(1, count($documents));
+        }
 
-        // Test: Without preserveSequence (default), $sequence should be ignored
-        $database->setPreserveSequence(false);
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'ft' => 'donald duck',
+        ]));
 
-        $database->upsertDocuments($collectionName, [
-            new Document([
-                '$id' => 'doc1',
-                '$sequence' => 999, // Try to set a different sequence
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                ],
-                'name' => 'Alice Updated',
-            ]),
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'ft' => 'donald trump',
+        ]));
+
+        $documents = $database->find($collection, [
+            Query::search('ft', 'donald trump'),
+            Query::orderAsc('ft'),
         ]);
+        $this->assertEquals(2, count($documents));
 
-        $doc1Updated = $database->getDocument($collectionName, 'doc1');
-        $this->assertEquals('Alice Updated', $doc1Updated->getAttribute('name'));
-        $this->assertEquals($originalSeq1, $doc1Updated->getSequence()); // Sequence unchanged
+        $documents = $database->find($collection, [
+            Query::search('ft', '"donald trump"'), // Exact match
+        ]);
 
-        // Test: With preserveSequence=true, $sequence from document should be used
-        $database->setPreserveSequence(true);
+        $this->assertEquals(1, count($documents));
+    }
 
-        $database->upsertDocuments($collectionName, [
-            new Document([
-                '$id' => 'doc2',
-                '$sequence' => $originalSeq2, // Keep original sequence
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                ],
-                'name' => 'Bob Updated',
-            ]),
-        ]);
-
-        $doc2Updated = $database->getDocument($collectionName, 'doc2');
-        $this->assertEquals('Bob Updated', $doc2Updated->getAttribute('name'));
-        $this->assertEquals($originalSeq2, $doc2Updated->getSequence()); // Sequence preserved
+    /**
+     * Regression: accented characters and non-operator special chars
+     * previously caused SQLSTATE[42000] syntax error in FTS BOOLEAN MODE.
+     *
+     * @see https://appwrite.sentry.io/issues/5628237003
+     */
+    public function testFindFulltextAccentedAndSpecialChars(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Test: withPreserveSequence helper
-        $database->setPreserveSequence(false);
+        if (! $database->getAdapter()->supports(Capability::Fulltext)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $doc1 = $database->getDocument($collectionName, 'doc1');
-        $currentSeq1 = $doc1->getSequence();
+        $collection = 'full_text_unicode';
+        $database->createCollection(new Collection(id: $collection, permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users()),
+        ]));
 
-        $database->withPreserveSequence(function () use ($database, $collectionName, $currentSeq1) {
-            $database->upsertDocuments($collectionName, [
-                new Document([
-                    '$id' => 'doc1',
-                    '$sequence' => $currentSeq1,
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::update(Role::any()),
-                    ],
-                    'name' => 'Alice Final',
-                ]),
-            ]);
-        });
+        $this->assertTrue($database->createAttribute($collection, Attribute::string(key: 'nombre', size: 128, required: true)));
+        $this->assertTrue($database->createIndex($collection, Index::fullText(key: 'nombre-ft', attributes: ['nombre'])));
 
-        $doc1Final = $database->getDocument($collectionName, 'doc1');
-        $this->assertEquals('Alice Final', $doc1Final->getAttribute('name'));
-        $this->assertEquals($currentSeq1, $doc1Final->getSequence());
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'nombre' => 'Luis García'
+        ]));
 
-        // Verify flag was reset after withPreserveSequence
-        $this->assertFalse($database->getPreserveSequence());
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'nombre' => 'Álvaro Yair Cuéllar'
+        ]));
 
-        // Test: With preserveSequence=true, invalid $sequence should throw error (SQL adapters only)
-        $database->setPreserveSequence(true);
+        $database->createDocument($collection, new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'nombre' => 'Fernando naïve über'
+        ]));
 
-        try {
-            $database->upsertDocuments($collectionName, [
-                new Document([
-                    '$id' => 'doc1',
-                    '$sequence' => 'abc', // Invalid sequence value
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::update(Role::any()),
-                    ],
-                    'name' => 'Alice Invalid',
-                ]),
-            ]);
-            // Schemaless adapters may not validate sequence type, so only fail for schemaful
-            if ($database->getAdapter()->getSupportForAttributes()) {
-                $this->fail('Expected StructureException for invalid sequence');
-            }
-        } catch (Throwable $e) {
-            if ($database->getAdapter()->getSupportForAttributes()) {
-                $this->assertInstanceOf(StructureException::class, $e);
-                $this->assertStringContainsString('sequence', $e->getMessage());
-            }
-        }
+        /**
+         * Accented characters must not cause FTS parser errors
+         */
+        $documents = $database->find($collection, [
+            Query::search('nombre', 'García'),
+        ]);
+        $this->assertGreaterThanOrEqual(1, count($documents));
 
-        $database->setPreserveSequence(false);
-        $database->deleteCollection($collectionName);
-    }
+        $documents = $database->find($collection, [
+            Query::search('nombre', 'Álvaro'),
+        ]);
+        $this->assertGreaterThanOrEqual(1, count($documents));
 
-    public function testRespectNulls(): Document
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $documents = $database->find($collection, [
+            Query::search('nombre', 'Cuéllar'),
+        ]);
+        $this->assertGreaterThanOrEqual(1, count($documents));
 
-        $database->createCollection('documents_nulls');
+        /**
+         * Non-operator special chars (! . #) were not stripped by old code,
+         * producing values like "!!!...###*" that crash MySQL's FTS parser.
+         */
+        $documents = $database->find($collection, [
+            Query::search('nombre', '!!!...###'),
+        ]);
+        $this->assertEquals(0, count($documents));
 
-        $this->assertEquals(true, $database->createAttribute('documents_nulls', 'string', Database::VAR_STRING, 128, false));
-        $this->assertEquals(true, $database->createAttribute('documents_nulls', 'integer', Database::VAR_INTEGER, 0, false));
-        $this->assertEquals(true, $database->createAttribute('documents_nulls', 'bigint', Database::VAR_INTEGER, 8, false));
-        $this->assertEquals(true, $database->createAttribute('documents_nulls', 'float', Database::VAR_FLOAT, 0, false));
-        $this->assertEquals(true, $database->createAttribute('documents_nulls', 'boolean', Database::VAR_BOOLEAN, 0, false));
+        $documents = $database->find($collection, [
+            Query::search('nombre', '$$$%%%^^^'),
+        ]);
+        $this->assertEquals(0, count($documents));
 
-        $document = $database->createDocument('documents_nulls', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-        ]));
+        /**
+         * FTS operator-only input also must not error
+         */
+        $documents = $database->find($collection, [
+            Query::search('nombre', '+-*@<>~'),
+        ]);
+        $this->assertEquals(0, count($documents));
 
-        $this->assertNotEmpty($document->getId());
-        $this->assertNull($document->getAttribute('string'));
-        $this->assertNull($document->getAttribute('integer'));
-        $this->assertNull($document->getAttribute('bigint'));
-        $this->assertNull($document->getAttribute('float'));
-        $this->assertNull($document->getAttribute('boolean'));
-        return $document;
+        /**
+         * Mixed special chars + accented word should still find results
+         */
+        $documents = $database->find($collection, [
+            Query::search('nombre', '@García!'),
+        ]);
+        $this->assertGreaterThanOrEqual(1, count($documents));
     }
 
-    public function testCreateDocumentDefaults(): void
+    public function testFindByID(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('defaults');
-
-        $this->assertEquals(true, $database->createAttribute('defaults', 'string', Database::VAR_STRING, 128, false, 'default'));
-        $this->assertEquals(true, $database->createAttribute('defaults', 'integer', Database::VAR_INTEGER, 0, false, 1));
-        $this->assertEquals(true, $database->createAttribute('defaults', 'float', Database::VAR_FLOAT, 0, false, 1.5));
-        $this->assertEquals(true, $database->createAttribute('defaults', 'boolean', Database::VAR_BOOLEAN, 0, false, true));
-        $this->assertEquals(true, $database->createAttribute('defaults', 'colors', Database::VAR_STRING, 32, false, ['red', 'green', 'blue'], true, true));
-        $this->assertEquals(true, $database->createAttribute('defaults', 'datetime', Database::VAR_DATETIME, 0, false, '2000-06-12T14:12:55.000+00:00', true, false, null, [], ['datetime']));
+        /**
+         * $id condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('$id', ['frozen']),
+        ]);
 
-        $document = $database->createDocument('defaults', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-        ]));
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals('Frozen', $documents[0]['name']);
+    }
 
-        $document2 = $database->getDocument('defaults', $document->getId());
-        $this->assertCount(4, $document2->getPermissions());
-        $this->assertEquals('read("any")', $document2->getPermissions()[0]);
-        $this->assertEquals('create("any")', $document2->getPermissions()[1]);
-        $this->assertEquals('update("any")', $document2->getPermissions()[2]);
-        $this->assertEquals('delete("any")', $document2->getPermissions()[3]);
+    public function testFindByInternalID(): void
+    {
+        $sequence = $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertNotEmpty($document->getId());
-        $this->assertIsString($document->getAttribute('string'));
-        $this->assertEquals('default', $document->getAttribute('string'));
-        $this->assertIsInt($document->getAttribute('integer'));
-        $this->assertEquals(1, $document->getAttribute('integer'));
-        $this->assertIsFloat($document->getAttribute('float'));
-        $this->assertEquals(1.5, $document->getAttribute('float'));
-        $this->assertIsArray($document->getAttribute('colors'));
-        $this->assertCount(3, $document->getAttribute('colors'));
-        $this->assertEquals('red', $document->getAttribute('colors')[0]);
-        $this->assertEquals('green', $document->getAttribute('colors')[1]);
-        $this->assertEquals('blue', $document->getAttribute('colors')[2]);
-        $this->assertEquals('2000-06-12T14:12:55.000+00:00', $document->getAttribute('datetime'));
+        /**
+         * Test that internal ID queries are handled correctly
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('$sequence', [$sequence]),
+        ]);
 
-        // cleanup collection
-        $database->deleteCollection('defaults');
+        $this->assertEquals(1, count($documents));
     }
 
-    /**
-     * When a document's UID changes on update, its permission rows in the
-     * collection's _perms table must follow the new UID. Otherwise the old
-     * rows are orphaned and the renamed document is left with no permissions,
-     * even when the permission set itself was not changed.
-     */
-    public function testUpdateDocumentChangeIdMigratesPermissions(): void
+    public function testOrSingleQuery(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $auth = $database->getAuthorization();
-
-        $collection = 'update_change_id_perms';
-
         try {
-            // documentSecurity with no collection-level permissions: reads are
-            // governed purely by the document's rows in the _perms table.
-            $database->createCollection($collection, permissions: [], documentSecurity: true);
-            $this->assertEquals(true, $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, false));
-
-            // Create a document whose read permission is scoped to a single role,
-            // so that find() must consult the _perms table to return it.
-            $document = $auth->skip(fn () => $database->createDocument($collection, new Document([
-                '$id' => 'old_id',
-                'name' => 'test',
-                '$permissions' => [
-                    Permission::read(Role::user('alice')),
-                    Permission::update(Role::user('alice')),
-                    Permission::delete(Role::user('alice')),
-                ],
-            ])));
-            $this->assertEquals('old_id', $document->getId());
-
-            // Sanity: as alice the document is visible via the _perms table.
-            $auth->addRole(Role::user('alice')->toString());
-            $this->assertCount(1, $database->find($collection));
-
-            // Rename the document WITHOUT changing its permission set.
-            $renamed = $auth->skip(fn () => $database->updateDocument($collection, 'old_id', new Document(\array_merge(
-                $document->getArrayCopy(),
-                ['$id' => 'new_id'],
-            ))));
-            $this->assertEquals('new_id', $renamed->getId());
-
-            // The old UID must no longer resolve to a document.
-            $this->assertTrue($auth->skip(fn () => $database->getDocument($collection, 'old_id'))->isEmpty());
-
-            // The new UID must exist and keep its permissions on the main row.
-            $newDoc = $auth->skip(fn () => $database->getDocument($collection, 'new_id'));
-            $this->assertFalse($newDoc->isEmpty());
-            $this->assertContains(Permission::read(Role::user('alice')), $newDoc->getPermissions());
-
-            // The crucial check: the permission rows must have migrated to the new
-            // UID in the _perms table. As alice, find() (which joins _perms) must
-            // still return exactly the renamed document. With orphaned rows under
-            // the old UID this returns 0.
-            $found = $database->find($collection);
-            $this->assertCount(1, $found);
-            $this->assertEquals('new_id', $found[0]->getId());
-
-            /**
-             * Second scenario: change the UID AND the permission set in the same
-             * update. Drop alice's access and grant bob instead. The removed rows
-             * must be gone, the added rows must land under the new UID, and nothing
-             * may be left orphaned under the old UID.
-             */
-            $rekeyed = $auth->skip(fn () => $database->updateDocument($collection, 'new_id', new Document(\array_merge(
-                $newDoc->getArrayCopy(),
-                [
-                    '$id' => 'final_id',
-                    '$permissions' => [
-                        Permission::read(Role::user('bob')),
-                        Permission::read(Role::user('bob')), // Duplication check
-                        Permission::update(Role::user('bob')),
-                        Permission::delete(Role::user('bob')),
-                    ],
-                ],
-            ))));
-            $this->assertEquals('final_id', $rekeyed->getId());
-
-            // The old UID must no longer resolve to a document.
-            $this->assertTrue($auth->skip(fn () => $database->getDocument($collection, 'new_id'))->isEmpty());
-
-            // The main row must reflect the new permission set.
-            $finalDoc = $auth->skip(fn () => $database->getDocument($collection, 'final_id'));
-            $this->assertFalse($finalDoc->isEmpty());
-            $this->assertContains(Permission::read(Role::user('bob')), $finalDoc->getPermissions());
-            $this->assertNotContains(Permission::read(Role::user('alice')), $finalDoc->getPermissions());
-
-            // alice's permission rows were removed: as alice nothing is returned.
-            $this->assertCount(0, $database->find($collection));
-
-            // bob's permission rows landed under the new UID: as bob the renamed
-            // document is returned via the _perms join.
-            $auth->addRole(Role::user('bob')->toString());
-            $foundAsBob = $database->find($collection);
-            $this->assertCount(1, $foundAsBob);
-            $this->assertEquals('final_id', $foundAsBob[0]->getId());
-        } finally {
-            $auth->removeRole(Role::user('alice')->toString());
-            $auth->removeRole(Role::user('bob')->toString());
-
-            $auth->skip(fn () => $database->deleteCollection($collection));
+            $database->find($this->getMoviesCollection(), [
+                Query::or([
+                    Query::equal('active', [true]),
+                ]),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertEquals('Invalid query: Or queries require at least two queries', $e->getMessage());
         }
     }
 
-    public function testIncreaseDecrease(): Document
+    public function testOrMultipleQueries(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = 'increase_decrease';
-        $database->createCollection($collection);
+        $queries = [
+            Query::or([
+                Query::equal('active', [true]),
+                Query::equal('name', ['Frozen II']),
+            ]),
+        ];
+        $this->assertCount(4, $database->find($this->getMoviesCollection(), $queries));
+        $this->assertEquals(4, $database->count($this->getMoviesCollection(), $queries));
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'increase', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'decrease', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'increase_text', Database::VAR_STRING, 255, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'increase_float', Database::VAR_FLOAT, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'sizes', Database::VAR_INTEGER, 8, required: false, array: true));
+        $queries = [
+            Query::equal('active', [true]),
+            Query::or([
+                Query::equal('name', ['Frozen']),
+                Query::equal('name', ['Frozen II']),
+                Query::equal('director', ['Joe Johnston']),
+            ]),
+        ];
 
-        $document = $database->createDocument($collection, new Document([
-            'increase' => 100,
-            'decrease' => 100,
-            'increase_float' => 100,
-            'increase_text' => 'some text',
-            'sizes' => [10, 20, 30],
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ]
-        ]));
+        $this->assertCount(3, $database->find($this->getMoviesCollection(), $queries));
+        $this->assertEquals(3, $database->count($this->getMoviesCollection(), $queries));
+    }
 
-        $updatedAt = $document->getUpdatedAt();
+    public function testOrNested(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        \usleep(2000); // Ensure $updatedAt differs when adapter timestamp precision is milliseconds
-
-        $doc = $database->increaseDocumentAttribute($collection, $document->getId(), 'increase', 1, 101);
-        $this->assertEquals(101, $doc->getAttribute('increase'));
-
-        $document = $database->getDocument($collection, $document->getId());
-        $this->assertEquals(101, $document->getAttribute('increase'));
-        $this->assertNotEquals($updatedAt, $document->getUpdatedAt());
-
-        $doc = $database->decreaseDocumentAttribute($collection, $document->getId(), 'decrease', 1, 98);
-        $this->assertEquals(99, $doc->getAttribute('decrease'));
-        $document = $database->getDocument($collection, $document->getId());
-        $this->assertEquals(99, $document->getAttribute('decrease'));
-
-        $doc = $database->increaseDocumentAttribute($collection, $document->getId(), 'increase_float', 5.5, 110);
-        $this->assertEquals(105.5, $doc->getAttribute('increase_float'));
-        $document = $database->getDocument($collection, $document->getId());
-        $this->assertEquals(105.5, $document->getAttribute('increase_float'));
+        $queries = [
+            Query::select(['director']),
+            Query::equal('director', ['Joe Johnston']),
+            Query::or([
+                Query::equal('name', ['Frozen']),
+                Query::or([
+                    Query::equal('active', [true]),
+                    Query::equal('active', [false]),
+                ]),
+            ]),
+        ];
 
-        $doc = $database->decreaseDocumentAttribute($collection, $document->getId(), 'increase_float', 1.1, 100);
-        $this->assertEquals(104.4, $doc->getAttribute('increase_float'));
-        $document = $database->getDocument($collection, $document->getId());
-        $this->assertEquals(104.4, $document->getAttribute('increase_float'));
+        $documents = $database->find($this->getMoviesCollection(), $queries);
+        $this->assertCount(1, $documents);
+        $this->assertArrayNotHasKey('name', $documents[0]);
 
-        return $document;
+        $count = $database->count($this->getMoviesCollection(), $queries);
+        $this->assertEquals(1, $count);
     }
 
-    public function testCreateUpdateBigIntAndIncrementDecrement(): void
+    public function testAndSingleQuery(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = 'bigint_update_increase_decrease';
-        $database->createCollection($collection);
-
-        $this->assertEquals(true, $database->createAttribute($collection, 'inc', Database::VAR_BIGINT, 8, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'dec', Database::VAR_BIGINT, 8, true));
-
-        $document = $database->createDocument($collection, new Document([
-            'inc' => 10,
-            'dec' => 10,
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ]
-        ]));
-
-        $this->assertIsInt($document->getAttribute('inc'));
-        $this->assertEquals(10, $document->getAttribute('inc'));
-
-        // Verify regular update works for bigint attributes
-        $updated = $database->updateDocument($collection, $document->getId(), new Document([
-            'inc' => 20,
-        ]));
-        $this->assertEquals(20, $updated->getAttribute('inc'));
-
-        // Verify atomic increment/decrement supports bigint schema attributes
-        $afterInc = $database->increaseDocumentAttribute($collection, $document->getId(), 'inc', 5, 30);
-        $this->assertEquals(25, $afterInc->getAttribute('inc'));
-
-        $afterDec = $database->decreaseDocumentAttribute($collection, $document->getId(), 'dec', 3, 7);
-        $this->assertEquals(7, $afterDec->getAttribute('dec'));
+        try {
+            $database->find($this->getMoviesCollection(), [
+                Query::and([
+                    Query::equal('active', [true]),
+                ]),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertEquals('Invalid query: And queries require at least two queries', $e->getMessage());
+        }
     }
 
-    /**
-     * @depends testIncreaseDecrease
-     */
-    public function testIncreaseLimitMax(Document $document): void
+    public function testAndMultipleQueries(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->expectException(Exception::class);
-        $this->assertEquals(true, $database->increaseDocumentAttribute('increase_decrease', $document->getId(), 'increase', 10.5, 102.4));
+        $queries = [
+            Query::and([
+                Query::equal('active', [true]),
+                Query::equal('name', ['Frozen II']),
+            ]),
+        ];
+        $this->assertCount(1, $database->find($this->getMoviesCollection(), $queries));
+        $this->assertEquals(1, $database->count($this->getMoviesCollection(), $queries));
     }
 
-    /**
-     * @depends testIncreaseDecrease
-     */
-    public function testDecreaseLimitMin(Document $document): void
+    public function testAndNested(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        try {
-            $database->decreaseDocumentAttribute(
-                'increase_decrease',
-                $document->getId(),
-                'decrease',
-                10,
-                99
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-        }
+        $queries = [
+            Query::or([
+                Query::equal('active', [false]),
+                Query::and([
+                    Query::equal('active', [true]),
+                    Query::equal('name', ['Frozen']),
+                ]),
+            ]),
+        ];
 
-        try {
-            $database->decreaseDocumentAttribute(
-                'increase_decrease',
-                $document->getId(),
-                'decrease',
-                1000,
-                0
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(LimitException::class, $e);
-        }
+        $documents = $database->find($this->getMoviesCollection(), $queries);
+        $this->assertCount(3, $documents);
+
+        $count = $database->count($this->getMoviesCollection(), $queries);
+        $this->assertEquals(3, $count);
     }
 
-    /**
-     * @depends testIncreaseDecrease
-     */
-    public function testIncreaseTextAttribute(Document $document): void
+    public function testFindNull(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        try {
-            $this->assertEquals(false, $database->increaseDocumentAttribute('increase_decrease', $document->getId(), 'increase_text'));
-            $this->fail('Expected TypeException not thrown');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(TypeException::class, $e, $e->getMessage());
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::isNull('nullable'),
+        ]);
+
+        $this->assertEquals(5, count($documents));
     }
 
-    /**
-     * @depends testIncreaseDecrease
-     */
-    public function testIncreaseArrayAttribute(Document $document): void
+    public function testFindNotNull(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        try {
-            $this->assertEquals(false, $database->increaseDocumentAttribute('increase_decrease', $document->getId(), 'sizes'));
-            $this->fail('Expected TypeException not thrown');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(TypeException::class, $e);
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::isNotNull('nullable'),
+        ]);
+
+        $this->assertEquals(1, count($documents));
     }
 
-    /**
-     * @depends testIncreaseDecrease
-     */
-    public function testIncreaseDecreasePreserveDates(Document $document): void
+    public function testFindStartsWith(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->setPreserveDates(true);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::startsWith('name', 'Work'),
+        ]);
 
-        try {
-            $before = $database->getDocument('increase_decrease', $document->getId());
-            $updatedAt = $before->getUpdatedAt();
-            $increase = $before->getAttribute('increase');
-            $decrease = $before->getAttribute('decrease');
+        $this->assertEquals(2, count($documents));
 
-            $database->increaseDocumentAttribute('increase_decrease', $document->getId(), 'increase', 1);
+        if ($this->getDatabase()->getAdapter() instanceof SQL) {
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::startsWith('name', '%ork'),
+            ]);
+        } else {
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::startsWith('name', '.*ork'),
+            ]);
+        }
 
-            $after = $database->getDocument('increase_decrease', $document->getId());
-            $this->assertSame($increase + 1, $after->getAttribute('increase'));
-            $this->assertSame($updatedAt, $after->getUpdatedAt());
+        $this->assertEquals(0, count($documents));
+    }
 
-            $database->decreaseDocumentAttribute('increase_decrease', $document->getId(), 'decrease', 1);
+    public function testFindStartsWithWords(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-            $after = $database->getDocument('increase_decrease', $document->getId());
-            $this->assertSame($decrease - 1, $after->getAttribute('decrease'));
-            $this->assertSame($updatedAt, $after->getUpdatedAt());
-        } finally {
-            $database->setPreserveDates(false);
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::startsWith('name', 'Work in Progress'),
+        ]);
+
+        $this->assertEquals(2, count($documents));
     }
 
-    /**
-      * @depends testCreateDocument
-      */
-    public function testGetDocument(Document $document): Document
+    public function testFindEndsWith(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->getDocument('documents', $document->getId());
-
-        $this->assertNotEmpty($document->getId());
-        $this->assertIsString($document->getAttribute('string'));
-        $this->assertEquals('text📝', $document->getAttribute('string'));
-        $this->assertIsInt($document->getAttribute('integer_signed'));
-        $this->assertEquals(-Database::MAX_INT, $document->getAttribute('integer_signed'));
-        $this->assertIsFloat($document->getAttribute('float_signed'));
-        $this->assertEquals(-5.55, $document->getAttribute('float_signed'));
-        $this->assertIsFloat($document->getAttribute('float_unsigned'));
-        $this->assertEquals(5.55, $document->getAttribute('float_unsigned'));
-        $this->assertIsBool($document->getAttribute('boolean'));
-        $this->assertEquals(true, $document->getAttribute('boolean'));
-        $this->assertIsArray($document->getAttribute('colors'));
-        $this->assertEquals(['pink', 'green', 'blue'], $document->getAttribute('colors'));
-        $this->assertEquals('Works', $document->getAttribute('with-dash'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::endsWith('name', 'Marvel'),
+        ]);
 
-        return $document;
+        $this->assertEquals(1, count($documents));
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testGetDocumentSelect(Document $document): Document
+    public function testFindNotContains(): void
     {
-        $documentId = $document->getId();
-
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->getDocument('documents', $documentId, [
-            Query::select(['string', 'integer_signed']),
+        if (! $database->getAdapter()->supports(Capability::QueryContains)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        // Test notContains with array attributes - should return documents that don't contain specified genres
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('genres', ['comics']),
         ]);
 
-        $this->assertFalse($document->isEmpty());
-        $this->assertIsString($document->getAttribute('string'));
-        $this->assertEquals('text📝', $document->getAttribute('string'));
-        $this->assertIsInt($document->getAttribute('integer_signed'));
-        $this->assertEquals(-Database::MAX_INT, $document->getAttribute('integer_signed'));
-        $this->assertArrayNotHasKey('float', $document->getAttributes());
-        $this->assertArrayNotHasKey('boolean', $document->getAttributes());
-        $this->assertArrayNotHasKey('colors', $document->getAttributes());
-        $this->assertArrayNotHasKey('with-dash', $document->getAttributes());
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayHasKey('$sequence', $document);
-        $this->assertArrayHasKey('$createdAt', $document);
-        $this->assertArrayHasKey('$updatedAt', $document);
-        $this->assertArrayHasKey('$permissions', $document);
-        $this->assertArrayHasKey('$collection', $document);
+        $this->assertEquals(4, count($documents)); // 6 readable movies (user:x role added earlier) minus 2 with 'comics' genre
 
-        $document = $database->getDocument('documents', $documentId, [
-            Query::select(['string', 'integer_signed', '$id']),
+        // Test notContains with multiple values (AND logic - exclude documents containing ANY of these)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('genres', ['comics', 'kids']),
         ]);
 
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayHasKey('$sequence', $document);
-        $this->assertArrayHasKey('$createdAt', $document);
-        $this->assertArrayHasKey('$updatedAt', $document);
-        $this->assertArrayHasKey('$permissions', $document);
-        $this->assertArrayHasKey('$collection', $document);
-        $this->assertArrayHasKey('string', $document);
-        $this->assertArrayHasKey('integer_signed', $document);
-        $this->assertArrayNotHasKey('float', $document);
+        $this->assertEquals(2, count($documents)); // Only 'Work in Progress' and 'Work in Progress 2' have neither 'comics' nor 'kids'
 
-        return $document;
-    }
-    /**
-     * @return array<string, mixed>
-     */
-    public function testFind(): array
-    {
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        // Test notContains with non-existent genre - should return all readable documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('genres', ['non-existent']),
+        ]);
 
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals(6, count($documents));
 
-        $database->createCollection('movies', permissions: [
-            Permission::create(Role::any()),
-            Permission::update(Role::users())
+        // Test notContains with string attribute (substring search)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('name', ['Captain']),
+        ]);
+        $this->assertEquals(4, count($documents)); // 6 readable movies minus 2 containing 'Captain'
+
+        // Test notContains combined with other queries (AND logic)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('genres', ['comics']),
+            Query::greaterThan('year', 2000),
         ]);
+        $this->assertLessThanOrEqual(4, count($documents)); // Subset of readable movies without 'comics' and after 2000
 
-        $this->assertEquals(true, $database->createAttribute('movies', 'name', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'director', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'year', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'price', Database::VAR_FLOAT, 0, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'active', Database::VAR_BOOLEAN, 0, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'genres', Database::VAR_STRING, 32, true, null, true, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'with-dash', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('movies', 'nullable', Database::VAR_STRING, 128, false));
+        // Test notContains with case sensitivity
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notContains('genres', ['COMICS']), // Different case
+        ]);
+        $this->assertEquals(6, count($documents)); // All readable movies since case doesn't match
 
+        // Test error handling for invalid attribute type
         try {
-            $database->createDocument('movies', new Document(['$id' => ['id_as_array']]));
+            $database->find($this->getMoviesCollection(), [
+                Query::notContains('price', [10.5]),
+            ]);
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            $this->assertEquals('$id must be of type string', $e->getMessage());
-            $this->assertInstanceOf(StructureException::class, $e);
+            $this->assertEquals('Invalid query: Cannot query notContains on attribute "price" because it is not an array, string, or object.', $e->getMessage());
+            $this->assertTrue($e instanceof DatabaseException);
         }
+    }
 
-        $document = $database->createDocument('movies', new Document([
-            '$id' => ID::custom('frozen'),
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Frozen',
-            'director' => 'Chris Buck & Jennifer Lee',
-            'year' => 2013,
-            'price' => 39.50,
-            'active' => true,
-            'genres' => ['animation', 'kids'],
-            'with-dash' => 'Works'
-        ]));
+    public function testFindNotSearch(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Frozen II',
-            'director' => 'Chris Buck & Jennifer Lee',
-            'year' => 2019,
-            'price' => 39.50,
-            'active' => true,
-            'genres' => ['animation', 'kids'],
-            'with-dash' => 'Works'
-        ]));
+        // Only test if fulltext search is supported
+        if ($this->getDatabase()->getAdapter()->supports(Capability::Fulltext)) {
+            // Ensure fulltext index exists (may already exist from previous tests)
+            try {
+                $database->createIndex($this->getMoviesCollection(), Index::fullText(key: 'name', attributes: ['name']));
+            } catch (Throwable $e) {
+                // Index may already exist, ignore duplicate error
+                if (! str_contains($e->getMessage(), 'already exists')) {
+                    throw $e;
+                }
+            }
 
-        $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Captain America: The First Avenger',
-            'director' => 'Joe Johnston',
-            'year' => 2011,
-            'price' => 25.94,
-            'active' => true,
-            'genres' => ['science fiction', 'action', 'comics'],
-            'with-dash' => 'Works2'
-        ]));
+            // Test notSearch - should return documents that don't match the search term
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notSearch('name', 'captain'),
+            ]);
 
-        $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Captain Marvel',
-            'director' => 'Anna Boden & Ryan Fleck',
-            'year' => 2019,
-            'price' => 25.99,
-            'active' => true,
-            'genres' => ['science fiction', 'action', 'comics'],
-            'with-dash' => 'Works2'
-        ]));
+            $this->assertEquals(4, count($documents)); // 6 readable movies (user:x role added earlier) minus 2 with 'captain' in name
 
-        $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Work in Progress',
-            'director' => 'TBD',
-            'year' => 2025,
-            'price' => 0.0,
-            'active' => false,
-            'genres' => [],
-            'with-dash' => 'Works3'
-        ]));
+            // Test notSearch with term that doesn't exist - should return all readable documents
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notSearch('name', 'nonexistent'),
+            ]);
 
-        $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::user('x')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Work in Progress 2',
-            'director' => 'TBD',
-            'year' => 2026,
-            'price' => 0.0,
-            'active' => false,
-            'genres' => [],
-            'with-dash' => 'Works3',
-            'nullable' => 'Not null'
-        ]));
+            $this->assertEquals(6, count($documents));
 
-        return [
-            '$sequence' => $document->getSequence()
-        ];
+            // Test notSearch with partial term
+            if ($this->getDatabase()->getAdapter()->supports(Capability::FulltextWildcard)) {
+                $documents = $database->find($this->getMoviesCollection(), [
+                    Query::notSearch('name', 'cap'),
+                ]);
+
+                $this->assertEquals(4, count($documents)); // 6 readable movies minus 2 matching 'cap*'
+            }
+
+            // Test notSearch with empty string - should return all readable documents
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notSearch('name', ''),
+            ]);
+            $this->assertEquals(6, count($documents)); // All readable movies since empty search matches nothing
+
+            // Test notSearch combined with other filters
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notSearch('name', 'captain'),
+                Query::lessThan('year', 2010),
+            ]);
+            $this->assertLessThanOrEqual(4, count($documents)); // Subset of non-captain movies before 2010
+
+            // Test notSearch with special characters
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notSearch('name', '@#$%'),
+            ]);
+            $this->assertEquals(6, count($documents)); // All readable movies since special chars don't match
+        }
+
+        $this->assertEquals(true, true); // Test must do an assertion
     }
 
-    /**
-    * @depends testFind
-    */
-    public function testFindOne(): void
+    public function testFindNotStartsWith(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->findOne('movies', [
-            Query::offset(2),
-            Query::orderAsc('name')
+        // Test notStartsWith - should return documents that don't start with 'Work'
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', 'Work'),
         ]);
 
-        $this->assertFalse($document->isEmpty());
-        $this->assertEquals('Frozen', $document->getAttribute('name'));
+        $this->assertEquals(4, count($documents)); // All movies except the 2 starting with 'Work'
 
-        $document = $database->findOne('movies', [
-            Query::offset(10)
+        // Test notStartsWith with non-existent prefix - should return all documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', 'NonExistent'),
         ]);
-        $this->assertTrue($document->isEmpty());
-    }
-
-    public function testFindBasicChecks(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
 
-        $documents = $database->find('movies');
-        $movieDocuments = $documents;
+        $this->assertEquals(6, count($documents));
 
-        $this->assertEquals(5, count($documents));
-        $this->assertNotEmpty($documents[0]->getId());
-        $this->assertEquals('movies', $documents[0]->getCollection());
-        $this->assertEquals(['any', 'user:1', 'user:2'], $documents[0]->getRead());
-        $this->assertEquals(['any', 'user:1x', 'user:2x'], $documents[0]->getWrite());
-        $this->assertEquals('Frozen', $documents[0]->getAttribute('name'));
-        $this->assertEquals('Chris Buck & Jennifer Lee', $documents[0]->getAttribute('director'));
-        $this->assertIsString($documents[0]->getAttribute('director'));
-        $this->assertEquals(2013, $documents[0]->getAttribute('year'));
-        $this->assertIsInt($documents[0]->getAttribute('year'));
-        $this->assertEquals(39.50, $documents[0]->getAttribute('price'));
-        $this->assertIsFloat($documents[0]->getAttribute('price'));
-        $this->assertEquals(true, $documents[0]->getAttribute('active'));
-        $this->assertIsBool($documents[0]->getAttribute('active'));
-        $this->assertEquals(['animation', 'kids'], $documents[0]->getAttribute('genres'));
-        $this->assertIsArray($documents[0]->getAttribute('genres'));
-        $this->assertEquals('Works', $documents[0]->getAttribute('with-dash'));
-
-        // Alphabetical order
-        $sortedDocuments = $movieDocuments;
-        \usort($sortedDocuments, function ($doc1, $doc2) {
-            return strcmp($doc1['$id'], $doc2['$id']);
-        });
+        // Test notStartsWith with wildcard characters (should treat them literally)
+        if ($this->getDatabase()->getAdapter() instanceof SQL) {
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notStartsWith('name', '%ork'),
+            ]);
+        } else {
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::notStartsWith('name', '.*ork'),
+            ]);
+        }
 
-        $firstDocumentId = $sortedDocuments[0]->getId();
-        $lastDocumentId = $sortedDocuments[\count($sortedDocuments) - 1]->getId();
+        $this->assertEquals(6, count($documents)); // Should return all since no movie starts with these patterns
 
-        /**
-         * Check $id: Notice, this orders ID names alphabetically, not by internal numeric ID
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('$id'),
+        // Test notStartsWith with empty string - should return no documents (all strings start with empty)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', ''),
         ]);
-        $this->assertEquals($lastDocumentId, $documents[0]->getId());
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderAsc('$id'),
+        $this->assertEquals(0, count($documents)); // No documents since all strings start with empty string
+
+        // Test notStartsWith with single character
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', 'C'),
         ]);
-        $this->assertEquals($firstDocumentId, $documents[0]->getId());
+        $this->assertGreaterThanOrEqual(4, count($documents)); // Movies not starting with 'C'
 
-        /**
-         * Check internal numeric ID sorting
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc(''),
+        // Test notStartsWith with case sensitivity (may be case-insensitive depending on DB)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', 'work'), // lowercase vs 'Work'
         ]);
-        $this->assertEquals($movieDocuments[\count($movieDocuments) - 1]->getId(), $documents[0]->getId());
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderAsc(''),
+        $this->assertGreaterThanOrEqual(4, count($documents)); // May match case-insensitively
+
+        // Test notStartsWith combined with other queries
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notStartsWith('name', 'Work'),
+            Query::equal('year', [2006]),
         ]);
-        $this->assertEquals($movieDocuments[0]->getId(), $documents[0]->getId());
+        $this->assertLessThanOrEqual(4, count($documents)); // Subset of non-Work movies from 2006
     }
 
-    public function testFindCheckPermissions(): void
+    public function testFindNotEndsWith(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * Check Permissions
-         */
-        $this->getDatabase()->getAuthorization()->addRole('user:x');
-        $documents = $database->find('movies');
-
-        $this->assertEquals(6, count($documents));
-    }
+        // Test notEndsWith - should return documents that don't end with 'Marvel'
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'Marvel'),
+        ]);
 
-    public function testFindCheckInteger(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'Marvel'
 
-        /**
-         * Query with dash attribute
-         */
-        $documents = $database->find('movies', [
-            Query::equal('with-dash', ['Works']),
+        // Test notEndsWith with non-existent suffix - should return all documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'NonExistent'),
         ]);
 
-        $this->assertEquals(2, count($documents));
+        $this->assertEquals(6, count($documents));
 
-        $documents = $database->find('movies', [
-            Query::equal('with-dash', ['Works2', 'Works3']),
+        // Test notEndsWith with partial suffix
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'vel'),
         ]);
 
-        $this->assertEquals(4, count($documents));
+        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'vel' (from 'Marvel')
 
-        /**
-         * Check an Integer condition
-         */
-        $documents = $database->find('movies', [
-            Query::equal('year', [2019]),
+        // Test notEndsWith with empty string - should return no documents (all strings end with empty)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', ''),
         ]);
+        $this->assertEquals(0, count($documents)); // No documents since all strings end with empty string
 
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals('Frozen II', $documents[0]['name']);
-        $this->assertEquals('Captain Marvel', $documents[1]['name']);
-    }
-
-    public function testFindBoolean(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Test notEndsWith with single character
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'l'),
+        ]);
+        $this->assertGreaterThanOrEqual(5, count($documents)); // Movies not ending with 'l'
 
-        /**
-         * Boolean condition
-         */
-        $documents = $database->find('movies', [
-            Query::equal('active', [true]),
+        // Test notEndsWith with case sensitivity (may be case-insensitive depending on DB)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'marvel'), // lowercase vs 'Marvel'
         ]);
+        $this->assertGreaterThanOrEqual(5, count($documents)); // May match case-insensitively
 
-        $this->assertEquals(4, count($documents));
+        // Test notEndsWith combined with limit
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEndsWith('name', 'Marvel'),
+            Query::limit(3),
+        ]);
+        $this->assertEquals(3, count($documents)); // Limited to 3 results
+        $this->assertLessThanOrEqual(5, count($documents)); // But still excluding Marvel movies
     }
 
-    public function testFindStringQueryEqual(): void
+    public function testFindOrderRandom(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * String condition
-         */
-        $documents = $database->find('movies', [
-            Query::equal('director', ['TBD']),
-        ]);
+        if (! $database->getAdapter()->supports(Capability::OrderRandom)) {
+            $this->expectNotToPerformAssertions();
 
-        $this->assertEquals(2, count($documents));
+            return;
+        }
 
-        $documents = $database->find('movies', [
-            Query::equal('director', ['']),
+        // Test orderRandom with default limit
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
+            Query::limit(1),
         ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertNotEmpty($documents[0]['name']); // Ensure we got a valid document
 
-        $this->assertEquals(0, count($documents));
-    }
+        // Test orderRandom with multiple documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
+            Query::limit(3),
+        ]);
+        $this->assertEquals(3, count($documents));
+
+        // Test that orderRandom returns different results (not guaranteed but highly likely)
+        $firstSet = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
+            Query::limit(3),
+        ]);
+        $secondSet = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
+            Query::limit(3),
+        ]);
 
+        // Extract IDs for comparison
+        $firstIds = array_map(fn ($doc) => $doc['$id'], $firstSet);
+        $secondIds = array_map(fn ($doc) => $doc['$id'], $secondSet);
 
-    public function testFindNotEqual(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // While not guaranteed to be different, with 6 movies and selecting 3,
+        // the probability of getting the same set in the same order is very low
+        // We'll just check that we got valid results
+        $this->assertEquals(3, count($firstIds));
+        $this->assertEquals(3, count($secondIds));
 
-        /**
-         * Not Equal query
-         */
-        $documents = $database->find('movies', [
-            Query::notEqual('director', 'TBD'),
+        // Test orderRandom with more than available documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
+            Query::limit(10), // We only have 6 movies
         ]);
+        $this->assertLessThanOrEqual(6, count($documents)); // Should return all available documents
 
-        $this->assertGreaterThan(0, count($documents));
-
+        // Test orderRandom with filters
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::greaterThan('price', 10),
+            Query::orderRandom(),
+            Query::limit(2),
+        ]);
+        $this->assertLessThanOrEqual(2, count($documents));
         foreach ($documents as $document) {
-            $this->assertTrue($document['director'] !== 'TBD');
+            $this->assertGreaterThan(10, $document['price']);
         }
 
-        $documents = $database->find('movies', [
-            Query::notEqual('director', ''),
+        // Test orderRandom without explicit limit (should use default)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderRandom(),
         ]);
-
-        $total = $database->count('movies');
-
-        $this->assertEquals($total, count($documents));
+        $this->assertGreaterThan(0, count($documents));
+        $this->assertLessThanOrEqual(25, count($documents)); // Default limit is 25
     }
 
-    public function testFindBetween(): void
+    public function testSum(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $documents = $database->find('movies', [
-            Query::between('price', 25.94, 25.99),
-        ]);
-        $this->assertEquals(2, count($documents));
-
-        $documents = $database->find('movies', [
-            Query::between('price', 30, 35),
-        ]);
-        $this->assertEquals(0, count($documents));
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
 
-        $documents = $database->find('movies', [
-            Query::between('$createdAt', '1975-12-06', '2050-12-06'),
-        ]);
-        $this->assertEquals(6, count($documents));
+        $sum = $database->sum($this->getMoviesCollection(), 'year', [Query::equal('year', [2019])]);
+        $this->assertEquals(2019 + 2019, $sum);
+        $sum = $database->sum($this->getMoviesCollection(), 'year');
+        $this->assertEquals(2013 + 2019 + 2011 + 2019 + 2025 + 2026, $sum);
+        $sum = $database->sum($this->getMoviesCollection(), 'price', [Query::equal('year', [2019])]);
+        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
+        $sum = $database->sum($this->getMoviesCollection(), 'price', [Query::equal('year', [2019])]);
+        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
 
-        $documents = $database->find('movies', [
-            Query::between('$updatedAt', '1975-12-06T07:08:49.733+02:00', '2050-02-05T10:15:21.825+00:00'),
-        ]);
-        $this->assertEquals(6, count($documents));
-    }
+        $sum = $database->sum($this->getMoviesCollection(), 'year', [Query::equal('year', [2019])], 1);
+        $this->assertEquals(2019, $sum);
 
-    public function testFindFloat(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
 
-        /**
-         * Float condition
-         */
-        $documents = $database->find('movies', [
-            Query::lessThan('price', 26.00),
-            Query::greaterThan('price', 25.98),
-        ]);
+        $sum = $database->sum($this->getMoviesCollection(), 'year', [Query::equal('year', [2019])]);
+        $this->assertEquals(2019 + 2019, $sum);
+        $sum = $database->sum($this->getMoviesCollection(), 'year');
+        $this->assertEquals(2013 + 2019 + 2011 + 2019 + 2025, $sum);
+        $sum = $database->sum($this->getMoviesCollection(), 'price', [Query::equal('year', [2019])]);
+        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
+        $sum = $database->sum($this->getMoviesCollection(), 'price', [Query::equal('year', [2019])]);
+        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
 
-        $this->assertEquals(1, count($documents));
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
     }
 
-    public function testFindContains(): void
+    public function testUpdateDocument(): void
     {
+        $document = $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
+        $document = $database->getDocument($this->getDocumentsCollection(), $document->getId());
 
-        if (!$database->getAdapter()->getSupportForQueryContains()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $document
+            ->setAttribute('string', 'text📝 updated')
+            ->setAttribute('integer_signed', -6)
+            ->setAttribute('integer_unsigned', 6)
+            ->setAttribute('float_signed', -5.56)
+            ->setAttribute('float_unsigned', 5.56)
+            ->setAttribute('boolean', false)
+            ->setAttribute('colors', 'red', SetType::Append)
+            ->setAttribute('with-dash', 'Works');
 
-        $documents = $database->find('movies', [
-            Query::contains('genres', ['comics'])
-        ]);
+        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
 
-        $this->assertEquals(2, count($documents));
+        $this->assertNotEmpty($new->getId());
+        $this->assertIsString($new->getAttribute('string'));
+        $this->assertEquals('text📝 updated', $new->getAttribute('string'));
+        $this->assertIsInt($new->getAttribute('integer_signed'));
+        $this->assertEquals(-6, $new->getAttribute('integer_signed'));
+        $this->assertIsInt($new->getAttribute('integer_unsigned'));
+        $this->assertEquals(6, $new->getAttribute('integer_unsigned'));
+        $this->assertIsFloat($new->getAttribute('float_signed'));
+        $this->assertEquals(-5.56, $new->getAttribute('float_signed'));
+        $this->assertIsFloat($new->getAttribute('float_unsigned'));
+        $this->assertEquals(5.56, $new->getAttribute('float_unsigned'));
+        $this->assertIsBool($new->getAttribute('boolean'));
+        $this->assertEquals(false, $new->getAttribute('boolean'));
+        $this->assertIsArray($new->getAttribute('colors'));
+        $this->assertEquals(['pink', 'green', 'blue', 'red'], $new->getAttribute('colors'));
+        $this->assertEquals('Works', $new->getAttribute('with-dash'));
 
-        /**
-         * Array contains OR condition
-         */
-        $documents = $database->find('movies', [
-            Query::contains('genres', ['comics', 'kids']),
-        ]);
+        $oldPermissions = $document->getPermissions();
 
-        $this->assertEquals(4, count($documents));
+        $new
+            ->setAttribute('$permissions', Permission::read(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::create(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::update(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::delete(Role::guests()), SetType::Append);
 
-        $documents = $database->find('movies', [
-            Query::contains('genres', ['non-existent']),
-        ]);
+        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
 
-        $this->assertEquals(0, count($documents));
+        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
 
-        try {
-            $database->find('movies', [
-                Query::contains('price', [10.5]),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertEquals('Invalid query: Cannot query contains on attribute "price" because it is not an array, string, or object.', $e->getMessage());
-            $this->assertTrue($e instanceof DatabaseException);
-        }
-    }
+        $this->assertContains('guests', $new->getRead());
+        $this->assertContains('guests', $new->getWrite());
+        $this->assertContains('guests', $new->getCreate());
+        $this->assertContains('guests', $new->getUpdate());
+        $this->assertContains('guests', $new->getDelete());
 
-    public function testFindFulltext(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $new->setAttribute('$permissions', $oldPermissions);
 
-        /**
-         * Fulltext search
-         */
-        if ($this->getDatabase()->getAdapter()->getSupportForFulltextIndex()) {
-            $success = $database->createIndex('movies', 'name', Database::INDEX_FULLTEXT, ['name']);
-            $this->assertEquals(true, $success);
+        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
 
-            $documents = $database->find('movies', [
-                Query::search('name', 'captain'),
-            ]);
+        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
 
-            $this->assertEquals(2, count($documents));
+        $this->assertNotContains('guests', $new->getRead());
+        $this->assertNotContains('guests', $new->getWrite());
+        $this->assertNotContains('guests', $new->getCreate());
+        $this->assertNotContains('guests', $new->getUpdate());
+        $this->assertNotContains('guests', $new->getDelete());
 
-            /**
-             * Fulltext search (wildcard)
-             */
+        // Test change document ID
+        $id = $new->getId();
+        $newId = 'new-id';
+        $new->setAttribute('$id', $newId);
+        $new = $this->getDatabase()->updateDocument($new->getCollection(), $id, $new);
+        $this->assertEquals($newId, $new->getId());
 
-            // TODO: Looks like the MongoDB implementation is a bit more complex, skipping that for now.
-            // TODO: I think this needs a changes? how do we distinguish between regular full text and wildcard?
+        // Reset ID
+        $new->setAttribute('$id', $id);
+        $new = $this->getDatabase()->updateDocument($new->getCollection(), $newId, $new);
+        $this->assertEquals($id, $new->getId());
+    }
 
-            if ($this->getDatabase()->getAdapter()->getSupportForFulltextWildCardIndex()) {
-                $documents = $database->find('movies', [
-                    Query::search('name', 'cap'),
-                ]);
+    public function testDeleteDocument(): void
+    {
+        $document = $this->initDocumentsFixture();
+        $result = $this->getDatabase()->deleteDocument($document->getCollection(), $document->getId());
+        $deleted = $this->getDatabase()->getDocument($document->getCollection(), $document->getId());
 
-                $this->assertEquals(2, count($documents));
-            }
-        }
+        $this->assertEquals(true, $result);
+        $this->assertEquals(true, $deleted->isEmpty());
 
-        $this->assertEquals(true, true); // Test must do an assertion
+        // Re-create the fixture document so subsequent tests can use it
+        $recreated = $this->getDatabase()->createDocument($this->getDocumentsCollection(), $document);
+        self::$documentsFixtureDoc = $recreated;
     }
-    public function testFindFulltextSpecialChars(): void
+
+    public function testUpdateDocuments(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForFulltextIndex()) {
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $collection = 'full_text';
-        $database->createCollection($collection, permissions: [
-            Permission::create(Role::any()),
-            Permission::update(Role::users())
-        ]);
-
-        $this->assertTrue($database->createAttribute($collection, 'ft', Database::VAR_STRING, 128, true));
-        $this->assertTrue($database->createIndex($collection, 'ft-index', Database::INDEX_FULLTEXT, ['ft']));
-
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'Alf: chapter_4@nasa.com'
-        ]));
+        $collection = 'testUpdateDocuments';
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $documents = $database->find($collection, [
-            Query::search('ft', 'chapter_4'),
-        ]);
-        $this->assertEquals(1, count($documents));
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'string', size: 100, format: ''),
+            Attribute::integer(key: 'integer', size: 10000, format: ''),
+        ], permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'al@ba.io +-*)(<>~'
-        ]));
+        for ($i = 0; $i < 10; $i++) {
+            $database->createDocument($collection, new Document([
+                '$id' => 'doc'.$i,
+                'string' => 'text📝 '.$i,
+                'integer' => $i,
+            ]));
+        }
 
-        $documents = $database->find($collection, [
-            Query::search('ft', 'al@ba.io'), // === al ba io*
-        ]);
+        // Test Update half of the documents
+        $results = [];
+        $count = $database->updateDocuments($collection, new Document([
+            'string' => 'text📝 updated',
+        ]), [
+            Query::greaterThanEqual('integer', 5),
+        ], onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+        });
 
-        if ($database->getAdapter()->getSupportForFulltextWildcardIndex()) {
-            $this->assertEquals(0, count($documents));
-        } else {
-            $this->assertEquals(1, count($documents));
+        $this->assertEquals(5, $count);
+
+        foreach ($results as $document) {
+            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
         }
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'donald duck'
-        ]));
+        $updatedDocuments = $database->find($collection, [
+            Query::greaterThanEqual('integer', 5),
+        ]);
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'donald trump'
-        ]));
+        $this->assertCount(5, $updatedDocuments);
 
-        $documents = $database->find($collection, [
-            Query::search('ft', 'donald trump'),
-            Query::orderAsc('ft'),
-        ]);
-        $this->assertEquals(2, count($documents));
+        foreach ($updatedDocuments as $document) {
+            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
+            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
+        }
 
-        $documents = $database->find($collection, [
-            Query::search('ft', '"donald trump"'), // Exact match
+        $controlDocuments = $database->find($collection, [
+            Query::lessThan('integer', 5),
         ]);
 
-        $this->assertEquals(1, count($documents));
-    }
-
-    /**
-     * Regression: accented characters and non-operator special chars
-     * previously caused SQLSTATE[42000] syntax error in FTS BOOLEAN MODE.
-     *
-     * @see https://appwrite.sentry.io/issues/5628237003
-     */
-    public function testFindFulltextAccentedAndSpecialChars(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals(count($controlDocuments), 5);
 
-        if (!$database->getAdapter()->getSupportForFulltextIndex()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        foreach ($controlDocuments as $document) {
+            $this->assertNotEquals('text📝 updated', $document->getAttribute('string'));
         }
 
-        $collection = 'full_text_unicode';
-        $database->createCollection($collection, permissions: [
-            Permission::create(Role::any()),
-            Permission::update(Role::users())
-        ]);
+        // Test Update all documents
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'string' => 'text📝 updated all',
+        ])));
 
-        $this->assertTrue($database->createAttribute($collection, 'nombre', Database::VAR_STRING, 128, true));
-        $this->assertTrue($database->createIndex($collection, 'nombre-ft', Database::INDEX_FULLTEXT, ['nombre']));
+        $updatedDocuments = $database->find($collection);
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'nombre' => 'Luis García'
-        ]));
+        $this->assertEquals(count($updatedDocuments), 10);
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'nombre' => 'Álvaro Yair Cuéllar'
-        ]));
+        foreach ($updatedDocuments as $document) {
+            $this->assertEquals('text📝 updated all', $document->getAttribute('string'));
+        }
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'nombre' => 'Fernando naïve über'
-        ]));
+        // TEST: Can't delete documents in the past
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
 
-        /**
-         * Accented characters must not cause FTS parser errors
-         */
-        $documents = $database->find($collection, [
-            Query::search('nombre', 'García'),
-        ]);
-        $this->assertGreaterThanOrEqual(1, count($documents));
+        try {
+            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($collection, $database) {
+                $database->updateDocuments($collection, new Document([
+                    'string' => 'text📝 updated all',
+                ]));
+            });
+            $this->fail('Failed to throw exception');
+        } catch (ConflictException $e) {
+            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
+        }
 
-        $documents = $database->find($collection, [
-            Query::search('nombre', 'Álvaro'),
-        ]);
-        $this->assertGreaterThanOrEqual(1, count($documents));
+        // Check collection level permissions
+        $database->updateCollection($collection, permissions: [
+            Permission::read(Role::user('asd')),
+            Permission::create(Role::user('asd')),
+            Permission::update(Role::user('asd')),
+            Permission::delete(Role::user('asd')),
+        ], documentSecurity: false);
 
-        $documents = $database->find($collection, [
-            Query::search('nombre', 'Cuéllar'),
-        ]);
-        $this->assertGreaterThanOrEqual(1, count($documents));
+        try {
+            $database->updateDocuments($collection, new Document([
+                'string' => 'text📝 updated all',
+            ]));
+            $this->fail('Failed to throw exception');
+        } catch (AuthorizationException $e) {
+            $this->assertStringStartsWith('Missing "update" permission for role "user:asd".', $e->getMessage());
+        }
 
-        /**
-         * Non-operator special chars (! . #) were not stripped by old code,
-         * producing values like "!!!...###*" that crash MySQL's FTS parser.
-         */
-        $documents = $database->find($collection, [
-            Query::search('nombre', '!!!...###'),
-        ]);
-        $this->assertEquals(0, count($documents));
+        // Check document level permissions
+        $database->updateCollection($collection, permissions: [], documentSecurity: true);
 
-        $documents = $database->find($collection, [
-            Query::search('nombre', '$$$%%%^^^'),
-        ]);
-        $this->assertEquals(0, count($documents));
+        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
+            $database->updateDocument($collection, 'doc0', new Document([
+                'string' => 'text📝 updated all',
+                '$permissions' => [
+                    Permission::read(Role::user('asd')),
+                    Permission::create(Role::user('asd')),
+                    Permission::update(Role::user('asd')),
+                    Permission::delete(Role::user('asd')),
+                ],
+            ]));
+        });
 
-        /**
-         * FTS operator-only input also must not error
-         */
-        $documents = $database->find($collection, [
-            Query::search('nombre', '+-*@<>~'),
-        ]);
-        $this->assertEquals(0, count($documents));
+        $this->getDatabase()->getAuthorization()->addRole(Role::user('asd')->toString());
+
+        $database->updateDocuments($collection, new Document([
+            'string' => 'permission text',
+        ]));
 
-        /**
-         * Mixed special chars + accented word should still find results
-         */
         $documents = $database->find($collection, [
-            Query::search('nombre', '@García!'),
+            Query::equal('string', ['permission text']),
         ]);
-        $this->assertGreaterThanOrEqual(1, count($documents));
-    }
 
-    public function testFindMultipleConditions(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertCount(1, $documents);
 
-        /**
-         * Multiple conditions
-         */
-        $documents = $database->find('movies', [
-            Query::equal('director', ['TBD']),
-            Query::equal('year', [2026]),
-        ]);
+        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
+            $unmodifiedDocuments = $database->find($collection, [
+                Query::equal('string', ['text📝 updated all']),
+            ]);
 
-        $this->assertEquals(1, count($documents));
+            $this->assertCount(9, $unmodifiedDocuments);
+        });
 
-        /**
-         * Multiple conditions and OR values
-         */
-        $documents = $database->find('movies', [
-            Query::equal('name', ['Frozen II', 'Captain Marvel']),
-        ]);
+        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
+            $database->updateDocuments($collection, new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+            ]));
+        });
 
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals('Frozen II', $documents[0]['name']);
-        $this->assertEquals('Captain Marvel', $documents[1]['name']);
-    }
+        // Test we can update more documents than batchSize
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'string' => 'batchSize Test',
+        ]), batchSize: 2));
 
-    public function testFindByID(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $documents = $database->find($collection);
 
-        /**
-         * $id condition
-         */
-        $documents = $database->find('movies', [
-            Query::equal('$id', ['frozen']),
-        ]);
+        foreach ($documents as $document) {
+            $this->assertEquals('batchSize Test', $document->getAttribute('string'));
+        }
 
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals('Frozen', $documents[0]['name']);
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
     }
-    /**
-     * @depends testFind
-     * @param array<string, mixed> $data
-     * @return void
-     * @throws \Utopia\Database\Exception
-     */
-    public function testFindByInternalID(array $data): void
+
+    public function testUpdateDocumentsWithCallbackSupport(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * Test that internal ID queries are handled correctly
-         */
-        $documents = $database->find('movies', [
-            Query::equal('$sequence', [$data['$sequence']]),
-        ]);
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
 
-        $this->assertEquals(1, count($documents));
-    }
+            return;
+        }
 
-    public function testFindOrderBy(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $collection = 'update_callback';
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        /**
-         * ORDER BY
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('name')
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'string', size: 100, format: ''),
+            Attribute::integer(key: 'integer', size: 10000, format: ''),
+        ], permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
+
+        for ($i = 0; $i < 10; $i++) {
+            $database->createDocument($collection, new Document([
+                '$id' => 'doc'.$i,
+                'string' => 'text📝 '.$i,
+                'integer' => $i,
+            ]));
+        }
+        // Test onNext is throwing the error without the onError
+        // a non existent document to test the error thrown
+        try {
+            $results = [];
+            $count = $database->updateDocuments($collection, new Document([
+                'string' => 'text📝 updated',
+            ]), [
+                Query::greaterThanEqual('integer', 100),
+            ], onNext: function ($doc) use (&$results) {
+                $results[] = $doc;
+                throw new Exception("Error thrown to test that update doesn't stop and error is caught");
+            });
+        } catch (Exception $e) {
+            $this->assertEquals("Error thrown to test that update doesn't stop and error is caught", $e->getMessage());
+        }
+
+        // Test Update half of the documents
+        $results = [];
+        $count = $database->updateDocuments($collection, new Document([
+            'string' => 'text📝 updated',
+        ]), [
+            Query::greaterThanEqual('integer', 5),
+        ], onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+            throw new Exception("Error thrown to test that update doesn't stop and error is caught");
+        }, onError: function ($e) {
+            $this->assertEquals("Error thrown to test that update doesn't stop and error is caught", $e->getMessage());
+        });
+
+        $this->assertEquals(5, $count);
+
+        foreach ($results as $document) {
+            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
+        }
+
+        $updatedDocuments = $database->find($collection, [
+            Query::greaterThanEqual('integer', 5),
         ]);
 
-        $this->assertEquals(6, count($documents));
-        $this->assertEquals('Frozen', $documents[0]['name']);
-        $this->assertEquals('Frozen II', $documents[1]['name']);
-        $this->assertEquals('Captain Marvel', $documents[2]['name']);
-        $this->assertEquals('Captain America: The First Avenger', $documents[3]['name']);
-        $this->assertEquals('Work in Progress', $documents[4]['name']);
-        $this->assertEquals('Work in Progress 2', $documents[5]['name']);
+        $this->assertCount(5, $updatedDocuments);
     }
-    public function testFindOrderByNatural(): void
+
+    public function testReadPermissionsSuccess(): void
     {
+        $this->initDocumentsFixture();
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY natural
-         */
-        $base = array_reverse($database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
+        $document = $database->createDocument($this->getDocumentsCollection(), new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'string' => 'text📝',
+            'integer_signed' => -Database::MAX_INT,
+            'integer_unsigned' => Database::MAX_INT,
+            'bigint_signed' => -Database::MAX_BIG_INT,
+            'bigint_unsigned' => Database::MAX_BIG_INT,
+            'float_signed' => -5.55,
+            'float_unsigned' => 5.55,
+            'boolean' => true,
+            'colors' => ['pink', 'green', 'blue'],
         ]));
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc(''),
-        ]);
 
-        $this->assertEquals(6, count($documents));
-        $this->assertEquals($base[0]['name'], $documents[0]['name']);
-        $this->assertEquals($base[1]['name'], $documents[1]['name']);
-        $this->assertEquals($base[2]['name'], $documents[2]['name']);
-        $this->assertEquals($base[3]['name'], $documents[3]['name']);
-        $this->assertEquals($base[4]['name'], $documents[4]['name']);
-        $this->assertEquals($base[5]['name'], $documents[5]['name']);
-    }
-    public function testFindOrderByMultipleAttributes(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals(false, $document->isEmpty());
 
-        /**
-         * ORDER BY - Multiple attributes
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderDesc('name')
-        ]);
+        $this->getDatabase()->getAuthorization()->cleanRoles();
 
-        $this->assertEquals(6, count($documents));
-        $this->assertEquals('Frozen II', $documents[0]['name']);
-        $this->assertEquals('Frozen', $documents[1]['name']);
-        $this->assertEquals('Captain Marvel', $documents[2]['name']);
-        $this->assertEquals('Captain America: The First Avenger', $documents[3]['name']);
-        $this->assertEquals('Work in Progress 2', $documents[4]['name']);
-        $this->assertEquals('Work in Progress', $documents[5]['name']);
+        $document = $database->getDocument($document->getCollection(), $document->getId());
+        $this->assertEquals(true, $document->isEmpty());
+
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
     }
 
-    public function testFindOrderByCursorAfter(): void
+    public function testWritePermissionsSuccess(): void
     {
+        $this->initDocumentsFixture();
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - After
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-        ]);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($movies[1])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
+        $this->expectException(AuthorizationException::class);
+        $database->createDocument($this->getDocumentsCollection(), new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'string' => 'text📝',
+            'integer_signed' => -Database::MAX_INT,
+            'integer_unsigned' => Database::MAX_INT,
+            'bigint_signed' => -Database::MAX_BIG_INT,
+            'bigint_unsigned' => Database::MAX_BIG_INT,
+            'float_signed' => -5.55,
+            'float_unsigned' => 5.55,
+            'boolean' => true,
+            'colors' => ['pink', 'green', 'blue'],
+        ]));
+    }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
+    public function testWritePermissionsUpdateFailure(): void
+    {
+        $this->initDocumentsFixture();
+        $this->expectException(AuthorizationException::class);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($movies[4])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        /**
-         * Multiple order by, Test tie-break on year 2019
-         */
-        $movies = $database->find('movies', [
-            Query::orderAsc('year'),
-            Query::orderAsc('price'),
-        ]);
+        $document = $database->createDocument($this->getDocumentsCollection(), new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'string' => 'text📝',
+            'integer_signed' => -Database::MAX_INT,
+            'integer_unsigned' => Database::MAX_INT,
+            'bigint_signed' => -Database::MAX_BIG_INT,
+            'bigint_unsigned' => Database::MAX_BIG_INT,
+            'float_signed' => -5.55,
+            'float_unsigned' => 5.55,
+            'boolean' => true,
+            'colors' => ['pink', 'green', 'blue'],
+        ]));
 
-        $this->assertEquals(6, count($movies));
+        $this->getDatabase()->getAuthorization()->cleanRoles();
 
-        $this->assertEquals($movies[0]['name'], 'Captain America: The First Avenger');
-        $this->assertEquals($movies[0]['year'], 2011);
-        $this->assertEquals($movies[0]['price'], 25.94);
+        $document = $database->updateDocument($this->getDocumentsCollection(), $document->getId(), new Document([
+            '$id' => ID::custom($document->getId()),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'string' => 'text📝',
+            'integer_signed' => 6,
+            'bigint_signed' => -Database::MAX_BIG_INT,
+            'float_signed' => -Database::MAX_DOUBLE,
+            'float_unsigned' => Database::MAX_DOUBLE,
+            'boolean' => true,
+            'colors' => ['pink', 'green', 'blue'],
+        ]));
 
-        $this->assertEquals($movies[1]['name'], 'Frozen');
-        $this->assertEquals($movies[1]['year'], 2013);
-        $this->assertEquals($movies[1]['price'], 39.5);
+    }
 
-        $this->assertEquals($movies[2]['name'], 'Captain Marvel');
-        $this->assertEquals($movies[2]['year'], 2019);
-        $this->assertEquals($movies[2]['price'], 25.99);
+    public function testUniqueIndexDuplicate(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals($movies[3]['name'], 'Frozen II');
-        $this->assertEquals($movies[3]['year'], 2019);
-        $this->assertEquals($movies[3]['price'], 39.5);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals($movies[4]['name'], 'Work in Progress');
-        $this->assertEquals($movies[4]['year'], 2025);
-        $this->assertEquals($movies[4]['price'], 0);
+        $this->assertEquals(true, $database->createIndex($this->getMoviesCollection(), Index::unique(key: 'uniqueIndex', attributes: ['name'], lengths: [128], orders: [Order::Asc])));
 
-        $this->assertEquals($movies[5]['name'], 'Work in Progress 2');
-        $this->assertEquals($movies[5]['year'], 2026);
-        $this->assertEquals($movies[5]['price'], 0);
-
-        $pos = 2;
-        $documents = $database->find('movies', [
-            Query::orderAsc('year'),
-            Query::orderAsc('price'),
-            Query::cursorAfter($movies[$pos])
-        ]);
-
-        $this->assertEquals(3, count($documents));
+        try {
+            $database->createDocument($this->getMoviesCollection(), new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::read(Role::user('1')),
+                    Permission::read(Role::user('2')),
+                    Permission::create(Role::any()),
+                    Permission::create(Role::user('1x')),
+                    Permission::create(Role::user('2x')),
+                    Permission::update(Role::any()),
+                    Permission::update(Role::user('1x')),
+                    Permission::update(Role::user('2x')),
+                    Permission::delete(Role::any()),
+                    Permission::delete(Role::user('1x')),
+                    Permission::delete(Role::user('2x')),
+                ],
+                'name' => 'Frozen',
+                'director' => 'Chris Buck & Jennifer Lee',
+                'year' => 2013,
+                'price' => 39.50,
+                'active' => true,
+                'genres' => ['animation', 'kids'],
+                'with-dash' => 'Works4',
+            ]));
 
-        foreach ($documents as $i => $document) {
-            $this->assertEquals($document['name'], $movies[$i + 1 + $pos]['name']);
-            $this->assertEquals($document['price'], $movies[$i + 1 + $pos]['price']);
-            $this->assertEquals($document['year'], $movies[$i + 1 + $pos]['year']);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
         }
     }
 
-
-    public function testFindOrderByCursorBefore(): void
+    public function testUniqueIndexDuplicateUpdate(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Before
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-        ]);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[5])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
+        // Ensure the unique index exists (created in testUniqueIndexDuplicate)
+        try {
+            $database->createIndex($this->getMoviesCollection(), Index::unique(key: 'uniqueIndex', attributes: ['name'], lengths: [128], orders: [Order::Asc]));
+        } catch (\Throwable) {
+            // Index may already exist
+        }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
+        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+        // create document then update to conflict with index
+        $document = $database->createDocument($this->getMoviesCollection(), new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::read(Role::user('1')),
+                Permission::read(Role::user('2')),
+                Permission::create(Role::any()),
+                Permission::create(Role::user('1x')),
+                Permission::create(Role::user('2x')),
+                Permission::update(Role::any()),
+                Permission::update(Role::user('1x')),
+                Permission::update(Role::user('2x')),
+                Permission::delete(Role::any()),
+                Permission::delete(Role::user('1x')),
+                Permission::delete(Role::user('2x')),
+            ],
+            'name' => 'Frozen 5',
+            'director' => 'Chris Buck & Jennifer Lee',
+            'year' => 2013,
+            'price' => 39.50,
+            'active' => true,
+            'genres' => ['animation', 'kids'],
+            'with-dash' => 'Works4',
+        ]));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[2])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
+        try {
+            $database->updateDocument($this->getMoviesCollection(), $document->getId(), $document->setAttribute('name', 'Frozen'));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
+        }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+        $database->deleteDocument($this->getMoviesCollection(), $document->getId());
     }
 
-    public function testFindOrderByAfterNaturalOrder(): void
+    public function propagateBulkDocuments(string $collection, int $amount = 10, bool $documentSecurity = false): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - After by natural order
-         */
-        $movies = array_reverse($database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-        ]));
+        for ($i = 0; $i < $amount; $i++) {
+            $database->createDocument($collection, new Document(
+                array_merge([
+                    '$id' => 'doc'.$i,
+                    'text' => 'value'.$i,
+                    'integer' => $i,
+                ], $documentSecurity ? [
+                    '$permissions' => [
+                        Permission::create(Role::any()),
+                        Permission::read(Role::any()),
+                    ],
+                ] : [])
+            ));
+        }
+    }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[1])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
+    public function testFulltextIndexWithInteger(): void
+    {
+        $this->initDocumentsFixture();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[4])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectException(Exception::class);
+            if (! $this->getDatabase()->getAdapter()->supports(Capability::Fulltext)) {
+                $this->expectExceptionMessage('Fulltext index is not supported');
+            } else {
+                $this->expectExceptionMessage('Attribute "integer_signed" cannot be part of a fulltext index, must be of type string');
+            }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+            $database->createIndex($this->getDocumentsCollection(), Index::fullText(key: 'fulltext_integer', attributes: ['string', 'integer_signed']));
+        } else {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
     }
-    public function testFindOrderByBeforeNaturalOrder(): void
+
+    public function testEnableDisableValidation(): void
     {
-        /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Before by natural order
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc(''),
-        ]);
+        $database->createCollection(new Collection(id: 'validation', permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorBefore($movies[5])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
+        $database->createAttribute('validation', Attribute::string(key: 'name', size: 10));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorBefore($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
+        $database->createDocument('validation', new Document([
+            '$id' => 'docwithmorethan36charsasitsidentifier',
+            'name' => 'value1',
+        ]));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorBefore($movies[2])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
+        try {
+            $database->find('validation', queries: [
+                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertNotSame('', $e->getMessage());
+        }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $database->disableValidation();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorBefore($movies[0])
+        $database->find('validation', queries: [
+            Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
         ]);
-        $this->assertEmpty(count($documents));
-    }
-
-    public function testFindOrderBySingleAttributeAfter(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Single Attribute After
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('year')
-        ]);
+        $database->enableValidation();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorAfter($movies[1])
-        ]);
-
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorAfter($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
+        try {
+            $database->find('validation', queries: [
+                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertNotSame('', $e->getMessage());
+        }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorAfter($movies[4])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
+        $database->skipValidation(function () use ($database) {
+            $database->find('validation', queries: [
+                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+            ]);
+        });
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+        $database->enableValidation();
     }
 
-
-    public function testFindOrderBySingleAttributeBefore(): void
+    public function testExceptionDuplicate(): void
     {
+        $document = $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Single Attribute Before
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('year')
-        ]);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[5])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[2])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
+        $document->setAttribute('$id', 'duplicated');
+        $document->removeAttribute('$sequence');
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $database->createDocument($document->getCollection(), $document);
+        $document->removeAttribute('$sequence');
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+        try {
+            $database->createDocument($document->getCollection(), $document);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
+        }
     }
 
-    public function testFindOrderByMultipleAttributeAfter(): void
+    public function testExceptionCaseInsensitiveDuplicate(): void
     {
+        $document = $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Multiple Attribute After
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year')
-        ]);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorAfter($movies[1])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
+        $document->setAttribute('$id', 'caseSensitive');
+        $document->removeAttribute('$sequence');
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorAfter($movies[3])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
+        $database->createDocument($document->getCollection(), $document);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorAfter($movies[4])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
+        $document->setAttribute('$id', 'CaseSensitive');
+        $document->removeAttribute('$sequence');
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+        try {
+            $database->createDocument($document->getCollection(), $document);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
+        }
     }
 
-    public function testFindOrderByMultipleAttributeBefore(): void
+    public function testEmptyTenant(): void
     {
+        $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Multiple Attribute Before
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year')
-        ]);
+        if ($database->getAdapter()->getSharedTables()) {
+            $documents = $database->find(
+                $this->getDocumentsCollection(),
+                [Query::select(['*'])] // Mongo bug with Integer UID
+            );
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[5])
-        ]);
+            $document = $documents[0];
+            $doc = $database->getDocument($document->getCollection(), $document->getId());
+            $this->assertEquals($document->getTenant(), $doc->getTenant());
 
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
+            return;
+        }
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[4])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
+        $doc = $database->createDocument($this->getDocumentsCollection(), new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'string' => 'tenant_test',
+            'integer_signed' => 1,
+            'integer_unsigned' => 1,
+            'bigint_signed' => 1,
+            'bigint_unsigned' => 1,
+            'float_signed' => 1.0,
+            'float_unsigned' => 1.0,
+            'boolean' => true,
+            'colors' => ['red'],
+            'empty' => [],
+            'with-dash' => 'test',
+        ]));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[2])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
+        $this->assertArrayHasKey('$id', $doc);
+        $this->assertArrayNotHasKey('$tenant', $doc);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $document = $database->getDocument($this->getDocumentsCollection(), $doc->getId());
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayNotHasKey('$tenant', $document);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+        $document = $database->updateDocument($this->getDocumentsCollection(), $document->getId(), $document);
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayNotHasKey('$tenant', $document);
+
+        $database->deleteDocument($this->getDocumentsCollection(), $document->getId());
     }
-    public function testFindOrderByAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
 
+    public function testDateTimeDocument(): void
+    {
         /**
-         * ORDER BY + CURSOR
+         * @var Database $database
          */
-        $documentsTest = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-        ]);
-        $documents = $database->find('movies', [
-            Query::limit(1),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::cursorAfter($documentsTest[0])
-        ]);
-
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
-    }
-    public function testFindOrderByIdAndCursor(): void
-    {
-        /** @var Database $database */
         $database = $this->getDatabase();
+        $collection = 'create_modify_dates';
+        $database->createCollection(new Collection(id: $collection));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::datetime(key: 'datetime', filters: ['datetime'])));
 
-        /**
-         * ORDER BY ID + CURSOR
-         */
-        $documentsTest = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('$id'),
-        ]);
-        $documents = $database->find('movies', [
-            Query::limit(1),
-            Query::offset(0),
-            Query::orderDesc('$id'),
-            Query::cursorAfter($documentsTest[0])
-        ]);
-
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
-    }
-
-    public function testFindOrderByCreateDateAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $date = '2000-01-01T10:00:00.000+00:00';
+        // test - default behaviour of external datetime attribute not changed
+        $doc = $database->createDocument($collection, new Document([
+            '$id' => 'doc1',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())],
+            'datetime' => '',
+        ]));
+        $this->assertNotEmpty($doc->getAttribute('datetime'));
+        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
 
-        /**
-         * ORDER BY CREATE DATE + CURSOR
-         */
-        $documentsTest = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('$createdAt'),
-        ]);
+        $doc = $database->getDocument($collection, 'doc1');
+        $this->assertNotEmpty($doc->getAttribute('datetime'));
+        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
 
-        $documents = $database->find('movies', [
-            Query::limit(1),
-            Query::offset(0),
-            Query::orderDesc('$createdAt'),
-            Query::cursorAfter($documentsTest[0])
-        ]);
+        $database->setPreserveDates(true);
+        // test - modifying $createdAt and $updatedAt
+        $doc = $database->createDocument($collection, new Document([
+            '$id' => 'doc2',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())],
+            '$createdAt' => $date,
+        ]));
 
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
-    }
+        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
 
-    public function testFindOrderByUpdateDateAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $doc = $database->getDocument($collection, 'doc2');
 
-        /**
-         * ORDER BY UPDATE DATE + CURSOR
-         */
-        $documentsTest = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('$updatedAt'),
-        ]);
-        $documents = $database->find('movies', [
-            Query::limit(1),
-            Query::offset(0),
-            Query::orderDesc('$updatedAt'),
-            Query::cursorAfter($documentsTest[0])
-        ]);
+        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
 
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
     }
 
-    /**
-     * A batch insert stamps every row with the same `$createdAt` — createDocuments() takes
-     * one timestamp for the whole batch — so ordering by that timestamp alone leaves the
-     * order of those rows to the tie break Database::find() appends.
-     *
-     * The tie break follows the direction of the leading timestamp, so a descending order
-     * returns the batch newest-inserted first. It used to be appended ascending regardless,
-     * which both reversed the rows inside a tied group and produced a mixed-direction
-     * ORDER BY that no ascending index can answer.
-     */
-    public function testFindOrderByCreateDateTieBreak(): void
+    public function testUpsertDateOperations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('tieBreak', permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-        ], documentSecurity: false);
-
-        $this->assertEquals(true, $database->createAttribute('tieBreak', 'name', Database::VAR_STRING, 128, true));
+        if (! ($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
 
-        $documents = [];
-        foreach (['alpha', 'bravo', 'charlie'] as $name) {
-            $documents[] = new Document([
-                'name' => $name,
-                '$permissions' => [Permission::read(Role::any())],
-            ]);
+            return;
         }
 
-        $this->assertEquals(3, $database->createDocuments('tieBreak', $documents));
+        $collection = 'upsert_date_operations';
+        $database->createCollection(new Collection(id: $collection));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128)));
 
-        $created = $database->find('tieBreak', [Query::orderAsc('$sequence')]);
-        $this->assertCount(3, $created);
+        $database->setPreserveDates(true);
 
-        // The batch shares one timestamp, otherwise the tie break is never consulted.
-        $this->assertEquals($created[0]->getCreatedAt(), $created[2]->getCreatedAt());
+        $createDate = '2000-01-01T10:00:00.000+00:00';
+        $updateDate = '2000-02-01T15:30:00.000+00:00';
+        $date1 = '2000-01-01T10:00:00.000+00:00';
+        $date2 = '2000-02-01T15:30:00.000+00:00';
+        $date3 = '2000-03-01T20:45:00.000+00:00';
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())];
 
-        $descending = $database->find('tieBreak', [Query::orderDesc('$createdAt')]);
-        $this->assertEquals(
-            [$created[2]->getSequence(), $created[1]->getSequence(), $created[0]->getSequence()],
-            \array_map(fn (Document $document) => $document->getSequence(), $descending)
-        );
+        // Test 1: Upsert new document with custom createdAt
+        $upsertResults = [];
+        $database->upsertDocuments($collection, [
+            new Document([
+                '$id' => 'upsert1',
+                '$permissions' => $permissions,
+                'string' => 'upsert1_initial',
+                '$createdAt' => $createDate,
+            ]),
+        ], onNext: function ($doc) use (&$upsertResults) {
+            $upsertResults[] = $doc;
+        });
+        $upsertDoc1 = $upsertResults[0];
 
-        $ascending = $database->find('tieBreak', [Query::orderAsc('$createdAt')]);
-        $this->assertEquals(
-            [$created[0]->getSequence(), $created[1]->getSequence(), $created[2]->getSequence()],
-            \array_map(fn (Document $document) => $document->getSequence(), $ascending)
-        );
+        $this->assertEquals($createDate, $upsertDoc1->getAttribute('$createdAt'));
+        $this->assertNotEquals($createDate, $upsertDoc1->getAttribute('$updatedAt'));
 
-        // The tie break sits behind the caller's own order, so `name` still decides the
-        // rows the timestamp ties — placing a unique key ahead of it would leave it unread.
-        $byName = $database->find('tieBreak', [
-            Query::orderDesc('$createdAt'),
-            Query::orderAsc('name'),
-        ]);
-        $this->assertEquals(
-            ['alpha', 'bravo', 'charlie'],
-            \array_map(fn (Document $document) => $document->getAttribute('name'), $byName)
-        );
-    }
+        // Test 2: Upsert existing document with custom updatedAt
+        $upsertDoc1->setAttribute('string', 'upsert1_updated');
+        $upsertDoc1->setAttribute('$updatedAt', $updateDate);
+        $updatedUpsertResults = [];
+        $database->upsertDocuments($collection, [$upsertDoc1], onNext: function ($doc) use (&$updatedUpsertResults) {
+            $updatedUpsertResults[] = $doc;
+        });
+        $updatedUpsertDoc1 = $updatedUpsertResults[0];
 
-    public function testFindCreatedBefore(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals($createDate, $updatedUpsertDoc1->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $updatedUpsertDoc1->getAttribute('$updatedAt'));
 
-        /**
-         * Test Query::createdBefore wrapper
-         */
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $pastDate = '1900-01-01T00:00:00.000Z';
+        // Test 3: Upsert new document with both custom dates
+        $upsertResults2 = [];
+        $database->upsertDocuments($collection, [
+            new Document([
+                '$id' => 'upsert2',
+                '$permissions' => $permissions,
+                'string' => 'upsert2_both_dates',
+                '$createdAt' => $createDate,
+                '$updatedAt' => $updateDate,
+            ]),
+        ], onNext: function ($doc) use (&$upsertResults2) {
+            $upsertResults2[] = $doc;
+        });
+        $upsertDoc2 = $upsertResults2[0];
 
-        $documents = $database->find('movies', [
-            Query::createdBefore($futureDate),
-            Query::limit(1)
-        ]);
+        $this->assertEquals($createDate, $upsertDoc2->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $upsertDoc2->getAttribute('$updatedAt'));
 
-        $this->assertGreaterThan(0, count($documents));
+        // Test 4: Upsert existing document with different dates
+        $upsertDoc2->setAttribute('string', 'upsert2_updated');
+        $upsertDoc2->setAttribute('$createdAt', $date3);
+        $upsertDoc2->setAttribute('$updatedAt', $date3);
+        $updatedUpsertResults2 = [];
+        $database->upsertDocuments($collection, [$upsertDoc2], onNext: function ($doc) use (&$updatedUpsertResults2) {
+            $updatedUpsertResults2[] = $doc;
+        });
+        $updatedUpsertDoc2 = $updatedUpsertResults2[0];
 
-        $documents = $database->find('movies', [
-            Query::createdBefore($pastDate),
-            Query::limit(1)
-        ]);
+        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$createdAt'));
+        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$updatedAt'));
 
-        $this->assertEquals(0, count($documents));
-    }
+        // Test 5: Upsert with preserve dates disabled
+        $database->setPreserveDates(false);
 
-    public function testFindCreatedAfter(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $customDate = '2000-01-01T10:00:00.000+00:00';
+        $upsertResults3 = [];
+        $database->upsertDocuments($collection, [
+            new Document([
+                '$id' => 'upsert3',
+                '$permissions' => $permissions,
+                'string' => 'upsert3_disabled',
+                '$createdAt' => $customDate,
+                '$updatedAt' => $customDate,
+            ]),
+        ], onNext: function ($doc) use (&$upsertResults3) {
+            $upsertResults3[] = $doc;
+        });
+        $upsertDoc3 = $upsertResults3[0];
 
-        /**
-         * Test Query::createdAfter wrapper
-         */
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $pastDate = '1900-01-01T00:00:00.000Z';
+        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$updatedAt'));
 
-        $documents = $database->find('movies', [
-            Query::createdAfter($pastDate),
-            Query::limit(1)
-        ]);
+        // Update with custom dates should also be ignored
+        $upsertDoc3->setAttribute('string', 'upsert3_updated');
+        $upsertDoc3->setAttribute('$createdAt', $customDate);
+        $upsertDoc3->setAttribute('$updatedAt', $customDate);
+        $updatedUpsertResults3 = [];
+        $database->upsertDocuments($collection, [$upsertDoc3], onNext: function ($doc) use (&$updatedUpsertResults3) {
+            $updatedUpsertResults3[] = $doc;
+        });
+        $updatedUpsertDoc3 = $updatedUpsertResults3[0];
 
-        $this->assertGreaterThan(0, count($documents));
+        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$updatedAt'));
 
-        $documents = $database->find('movies', [
-            Query::createdAfter($futureDate),
-            Query::limit(1)
-        ]);
+        // Test 6: Bulk upsert operations with custom dates
+        $database->setPreserveDates(true);
 
-        $this->assertEquals(0, count($documents));
-    }
+        // Test 7: Bulk upsert with different date configurations
+        $upsertDocuments = [
+            new Document([
+                '$id' => 'bulk_upsert1',
+                '$permissions' => $permissions,
+                'string' => 'bulk_upsert1_initial',
+                '$createdAt' => $createDate,
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert2',
+                '$permissions' => $permissions,
+                'string' => 'bulk_upsert2_initial',
+                '$updatedAt' => $updateDate,
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert3',
+                '$permissions' => $permissions,
+                'string' => 'bulk_upsert3_initial',
+                '$createdAt' => $createDate,
+                '$updatedAt' => $updateDate,
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert4',
+                '$permissions' => $permissions,
+                'string' => 'bulk_upsert4_initial',
+            ]),
+        ];
 
-    public function testFindUpdatedBefore(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $bulkUpsertResults = [];
+        $database->upsertDocuments($collection, $upsertDocuments, onNext: function ($doc) use (&$bulkUpsertResults) {
+            $bulkUpsertResults[] = $doc;
+        });
 
-        /**
-         * Test Query::updatedBefore wrapper
-         */
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $pastDate = '1900-01-01T00:00:00.000Z';
+        // Test 8: Verify initial bulk upsert state
+        foreach (['bulk_upsert1', 'bulk_upsert3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+        }
 
-        $documents = $database->find('movies', [
-            Query::updatedBefore($futureDate),
-            Query::limit(1)
-        ]);
+        foreach (['bulk_upsert2', 'bulk_upsert3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+        }
 
-        $this->assertGreaterThan(0, count($documents));
+        foreach (['bulk_upsert4'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt missing for $id");
+            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt missing for $id");
+        }
 
-        $documents = $database->find('movies', [
-            Query::updatedBefore($pastDate),
-            Query::limit(1)
+        // Test 9: Bulk upsert update with custom dates using updateDocuments
+        $newDate = '2000-04-01T12:00:00.000+00:00';
+        $updateUpsertDoc = new Document([
+            'string' => 'bulk_upsert_updated',
+            '$createdAt' => $newDate,
+            '$updatedAt' => $newDate,
         ]);
 
-        $this->assertEquals(0, count($documents));
-    }
-
-    public function testFindUpdatedAfter(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * Test Query::updatedAfter wrapper
-         */
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $pastDate = '1900-01-01T00:00:00.000Z';
+        $upsertIds = [];
+        foreach ($upsertDocuments as $doc) {
+            $upsertIds[] = $doc->getId();
+        }
 
-        $documents = $database->find('movies', [
-            Query::updatedAfter($pastDate),
-            Query::limit(1)
+        $database->updateDocuments($collection, $updateUpsertDoc, [
+            Query::equal('$id', $upsertIds),
         ]);
 
-        $this->assertGreaterThan(0, count($documents));
+        foreach ($upsertIds as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($newDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+            $this->assertEquals($newDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+            $this->assertEquals('bulk_upsert_updated', $doc->getAttribute('string'), "string mismatch for $id");
+        }
 
-        $documents = $database->find('movies', [
-            Query::updatedAfter($futureDate),
-            Query::limit(1)
+        // Test 10: checking by passing null to each
+        $updateUpsertDoc = new Document([
+            'string' => 'bulk_upsert_updated',
+            '$createdAt' => null,
+            '$updatedAt' => null,
         ]);
 
-        $this->assertEquals(0, count($documents));
-    }
+        $upsertIds = [];
+        foreach ($upsertDocuments as $doc) {
+            $upsertIds[] = $doc->getId();
+        }
 
-    public function testFindCreatedBetween(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $database->updateDocuments($collection, $updateUpsertDoc, [
+            Query::equal('$id', $upsertIds),
+        ]);
 
-        /**
-         * Test Query::createdBetween wrapper
-         */
-        $pastDate = '1900-01-01T00:00:00.000Z';
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $recentPastDate = '2020-01-01T00:00:00.000Z';
-        $nearFutureDate = '2025-01-01T00:00:00.000Z';
+        foreach ($upsertIds as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+        }
 
-        // All documents should be between past and future
-        $documents = $database->find('movies', [
-            Query::createdBetween($pastDate, $futureDate),
-            Query::limit(25)
-        ]);
+        // Test 11: Bulk upsert operations with upsertDocuments
+        $upsertUpdateDocuments = [];
+        foreach ($upsertDocuments as $doc) {
+            $updatedDoc = clone $doc;
+            $updatedDoc->setAttribute('string', 'bulk_upsert_updated_via_upsert');
+            $updatedDoc->setAttribute('$createdAt', $newDate);
+            $updatedDoc->setAttribute('$updatedAt', $newDate);
+            $upsertUpdateDocuments[] = $updatedDoc;
+        }
 
-        $this->assertGreaterThan(0, count($documents));
+        $upsertUpdateResults = [];
+        $countUpsertUpdate = $database->upsertDocuments($collection, $upsertUpdateDocuments, onNext: function ($doc) use (&$upsertUpdateResults) {
+            $upsertUpdateResults[] = $doc;
+        });
+        $this->assertEquals(4, $countUpsertUpdate);
 
-        // No documents should exist in this range
-        $documents = $database->find('movies', [
-            Query::createdBetween($pastDate, $pastDate),
-            Query::limit(25)
-        ]);
+        foreach ($upsertUpdateResults as $doc) {
+            $this->assertEquals($newDate, $doc->getAttribute('$createdAt'), 'createdAt mismatch for upsert update');
+            $this->assertEquals($newDate, $doc->getAttribute('$updatedAt'), 'updatedAt mismatch for upsert update');
+            $this->assertEquals('bulk_upsert_updated_via_upsert', $doc->getAttribute('string'), 'string mismatch for upsert update');
+        }
 
-        $this->assertEquals(0, count($documents));
+        // Test 12: Bulk upsert with preserve dates disabled
+        $database->setPreserveDates(false);
 
-        // Documents created between recent past and near future
-        $documents = $database->find('movies', [
-            Query::createdBetween($recentPastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        $customDate = 'should be ignored anyways so no error';
+        $upsertDisabledDocuments = [];
+        foreach ($upsertDocuments as $doc) {
+            $disabledDoc = clone $doc;
+            $disabledDoc->setAttribute('string', 'bulk_upsert_disabled');
+            $disabledDoc->setAttribute('$createdAt', $customDate);
+            $disabledDoc->setAttribute('$updatedAt', $customDate);
+            $upsertDisabledDocuments[] = $disabledDoc;
+        }
 
-        $count = count($documents);
+        $upsertDisabledResults = [];
+        $countUpsertDisabled = $database->upsertDocuments($collection, $upsertDisabledDocuments, onNext: function ($doc) use (&$upsertDisabledResults) {
+            $upsertDisabledResults[] = $doc;
+        });
+        $this->assertEquals(4, $countUpsertDisabled);
 
-        // Same count should be returned with expanded range
-        $documents = $database->find('movies', [
-            Query::createdBetween($pastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        foreach ($upsertDisabledResults as $doc) {
+            $this->assertNotEquals($customDate, $doc->getAttribute('$createdAt'), 'createdAt should not be custom date when disabled');
+            $this->assertNotEquals($customDate, $doc->getAttribute('$updatedAt'), 'updatedAt should not be custom date when disabled');
+            $this->assertEquals('bulk_upsert_disabled', $doc->getAttribute('string'), 'string mismatch for disabled upsert');
+        }
 
-        $this->assertGreaterThanOrEqual($count, count($documents));
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
     }
 
-    public function testFindUpdatedBetween(): void
+    public function testUpdateDocumentsCount(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * Test Query::updatedBetween wrapper
-         */
-        $pastDate = '1900-01-01T00:00:00.000Z';
-        $futureDate = '2050-01-01T00:00:00.000Z';
-        $recentPastDate = '2020-01-01T00:00:00.000Z';
-        $nearFutureDate = '2025-01-01T00:00:00.000Z';
+        if (! ($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
 
-        // All documents should be between past and future
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $futureDate),
-            Query::limit(25)
-        ]);
+            return;
+        }
 
-        $this->assertGreaterThan(0, count($documents));
+        $collectionName = 'update_count';
+        $database->createCollection(new Collection(id: $collectionName));
 
-        // No documents should exist in this range
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $pastDate),
-            Query::limit(25)
-        ]);
+        $database->createAttribute($collectionName, Attribute::string(key: 'key', size: 60));
+        $database->createAttribute($collectionName, Attribute::string(key: 'value', size: 60));
 
-        $this->assertEquals(0, count($documents));
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())];
 
-        // Documents updated between recent past and near future
-        $documents = $database->find('movies', [
-            Query::updatedBetween($recentPastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        $docs = [
+            new Document([
+                '$id' => 'bulk_upsert1',
+                '$permissions' => $permissions,
+                'key' => 'bulk_upsert1_initial',
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert2',
+                '$permissions' => $permissions,
+                'key' => 'bulk_upsert2_initial',
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert3',
+                '$permissions' => $permissions,
+                'key' => 'bulk_upsert3_initial',
+            ]),
+            new Document([
+                '$id' => 'bulk_upsert4',
+                '$permissions' => $permissions,
+                'key' => 'bulk_upsert4_initial',
+            ]),
+        ];
+        $upsertUpdateResults = [];
+        $count = $database->upsertDocuments($collectionName, $docs, onNext: function ($doc) use (&$upsertUpdateResults) {
+            $upsertUpdateResults[] = $doc;
+        });
+        $this->assertCount(4, $upsertUpdateResults);
+        $this->assertEquals(4, $count);
 
-        $count = count($documents);
+        $updates = new Document(['value' => 'test']);
+        $newDocs = [];
+        $count = $database->updateDocuments($collectionName, $updates, onNext: function ($doc) use (&$newDocs) {
+            $newDocs[] = $doc;
+        });
 
-        // Same count should be returned with expanded range
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        $this->assertCount(4, $newDocs);
+        $this->assertEquals(4, $count);
 
-        $this->assertGreaterThanOrEqual($count, count($documents));
+        $database->deleteCollection($collectionName);
     }
 
-    public function testFindLimit(): void
+    public function testUpsertWithJSONFilters(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * Limit
-         */
-        $documents = $database->find('movies', [
-            Query::limit(4),
-            Query::offset(0),
-            Query::orderAsc('name')
-        ]);
+        $database = static::getDatabase();
 
-        $this->assertEquals(4, count($documents));
-        $this->assertEquals('Captain America: The First Avenger', $documents[0]['name']);
-        $this->assertEquals('Captain Marvel', $documents[1]['name']);
-        $this->assertEquals('Frozen', $documents[2]['name']);
-        $this->assertEquals('Frozen II', $documents[3]['name']);
-    }
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
 
+            return;
+        }
 
-    public function testFindLimitAndOffset(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Create collection with JSON filter attribute
+        $collection = ID::unique();
+        $database->createCollection(new Collection(id: $collection, permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]));
 
-        /**
-         * Limit + Offset
-         */
-        $documents = $database->find('movies', [
-            Query::limit(4),
-            Query::offset(2),
-            Query::orderAsc('name')
-        ]);
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::string(key: 'metadata', size: 4000, required: true, filters: ['json']));
 
-        $this->assertEquals(4, count($documents));
-        $this->assertEquals('Frozen', $documents[0]['name']);
-        $this->assertEquals('Frozen II', $documents[1]['name']);
-        $this->assertEquals('Work in Progress', $documents[2]['name']);
-        $this->assertEquals('Work in Progress 2', $documents[3]['name']);
-    }
-
-    public function testFindOrQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ];
 
-        /**
-         * Test that OR queries are handled correctly
-         */
-        $documents = $database->find('movies', [
-            Query::equal('director', ['TBD', 'Joe Johnston']),
-            Query::equal('year', [2025]),
-        ]);
-        $this->assertEquals(1, count($documents));
-    }
+        // Test 1: Insertion (createDocument) with JSON filter
+        $docId1 = 'json-doc-1';
+        $initialMetadata = [
+            'version' => '1.0.0',
+            'tags' => ['php', 'database'],
+            'config' => [
+                'debug' => false,
+                'timeout' => 30,
+            ],
+        ];
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testFindEdgeCases(Document $document): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $document1 = $database->createDocument($collection, new Document([
+            '$id' => $docId1,
+            'name' => 'Initial Document',
+            'metadata' => $initialMetadata,
+            '$permissions' => $permissions,
+        ]));
 
-        $collection = 'edgeCases';
+        $this->assertEquals($docId1, $document1->getId());
+        $this->assertEquals('Initial Document', $document1->getAttribute('name'));
+        $this->assertIsArray($document1->getAttribute('metadata'));
+        $this->assertEquals('1.0.0', $document1->getAttribute('metadata')['version']);
+        $this->assertEquals(['php', 'database'], $document1->getAttribute('metadata')['tags']);
 
-        $database->createCollection($collection);
+        // Test 2: Update (updateDocument) with modified JSON filter
+        $updatedMetadata = [
+            'version' => '2.0.0',
+            'tags' => ['php', 'database', 'json'],
+            'config' => [
+                'debug' => true,
+                'timeout' => 60,
+                'cache' => true,
+            ],
+            'updated' => true,
+        ];
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'value', Database::VAR_STRING, 256, true));
+        $document1->setAttribute('name', 'Updated Document');
+        $document1->setAttribute('metadata', $updatedMetadata);
 
-        $values = [
-            'NormalString',
-            '{"type":"json","somekey":"someval"}',
-            '{NormalStringInBraces}',
-            '"NormalStringInDoubleQuotes"',
-            '{"NormalStringInDoubleQuotesAndBraces"}',
-            "'NormalStringInSingleQuotes'",
-            "{'NormalStringInSingleQuotesAndBraces'}",
-            "SingleQuote'InMiddle",
-            'DoubleQuote"InMiddle',
-            'Slash/InMiddle',
-            'Backslash\InMiddle',
-            'Colon:InMiddle',
-            '"quoted":"colon"'
-        ];
+        $updatedDoc = $database->updateDocument($collection, $docId1, $document1);
 
-        foreach ($values as $value) {
-            $database->createDocument($collection, new Document([
-                '$id' => ID::unique(),
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any())
-                ],
-                'value' => $value
-            ]));
-        }
+        $this->assertEquals($docId1, $updatedDoc->getId());
+        $this->assertEquals('Updated Document', $updatedDoc->getAttribute('name'));
+        $this->assertIsArray($updatedDoc->getAttribute('metadata'));
+        $metadata = $updatedDoc->getArray('metadata');
+        $this->assertEquals('2.0.0', $metadata['version']);
+        $this->assertEquals(['php', 'database', 'json'], $metadata['tags']);
+        $config = $metadata['config'] ?? null;
+        $this->assertIsArray($config);
+        $this->assertTrue($config['debug']);
+        $this->assertTrue($metadata['updated']);
 
-        /**
-         * Check Basic
-         */
-        $documents = $database->find($collection);
+        // Test 3: Upsert - Create new document (upsertDocument)
+        $docId2 = 'json-doc-2';
+        $newMetadata = [
+            'version' => '1.5.0',
+            'tags' => ['javascript', 'node'],
+            'config' => [
+                'debug' => false,
+                'timeout' => 45,
+            ],
+        ];
 
-        $this->assertEquals(count($values), count($documents));
-        $this->assertNotEmpty($documents[0]->getId());
-        $this->assertEquals($collection, $documents[0]->getCollection());
-        $this->assertEquals(['any'], $documents[0]->getRead());
-        $this->assertEquals(['any'], $documents[0]->getUpdate());
-        $this->assertEquals(['any'], $documents[0]->getDelete());
-        $this->assertEquals($values[0], $documents[0]->getAttribute('value'));
+        $document2 = new Document([
+            '$id' => $docId2,
+            'name' => 'New Upsert Document',
+            'metadata' => $newMetadata,
+            '$permissions' => $permissions,
+        ]);
 
-        /**
-         * Check `equals` query
-         */
-        foreach ($values as $value) {
-            $documents = $database->find($collection, [
-                Query::limit(25),
-                Query::equal('value', [$value])
-            ]);
+        $upsertedDoc = $database->upsertDocument($collection, $document2);
 
-            $this->assertEquals(1, count($documents));
-            $this->assertEquals($value, $documents[0]->getAttribute('value'));
-        }
-    }
+        $this->assertEquals($docId2, $upsertedDoc->getId());
+        $this->assertEquals('New Upsert Document', $upsertedDoc->getAttribute('name'));
+        $this->assertIsArray($upsertedDoc->getAttribute('metadata'));
+        $this->assertEquals('1.5.0', $upsertedDoc->getAttribute('metadata')['version']);
 
-    public function testOrSingleQuery(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Test 4: Upsert - Update existing document (upsertDocument)
+        $document2->setAttribute('name', 'Updated Upsert Document');
+        $document2->setAttribute('metadata', [
+            'version' => '2.5.0',
+            'tags' => ['javascript', 'node', 'typescript'],
+            'config' => [
+                'debug' => true,
+                'timeout' => 90,
+            ],
+            'migrated' => true,
+        ]);
 
-        try {
-            $database->find('movies', [
-                Query::or([
-                    Query::equal('active', [true])
-                ])
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Invalid query: Or queries require at least two queries', $e->getMessage());
-        }
-    }
+        $upsertedDoc2 = $database->upsertDocument($collection, $document2);
 
-    public function testOrMultipleQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals($docId2, $upsertedDoc2->getId());
+        $this->assertEquals('Updated Upsert Document', $upsertedDoc2->getAttribute('name'));
+        $this->assertIsArray($upsertedDoc2->getAttribute('metadata'));
+        $this->assertEquals('2.5.0', $upsertedDoc2->getAttribute('metadata')['version']);
+        $this->assertEquals(['javascript', 'node', 'typescript'], $upsertedDoc2->getAttribute('metadata')['tags']);
+        $this->assertTrue($upsertedDoc2->getAttribute('metadata')['migrated']);
 
-        $queries = [
-            Query::or([
-                Query::equal('active', [true]),
-                Query::equal('name', ['Frozen II'])
-            ])
-        ];
-        $this->assertCount(4, $database->find('movies', $queries));
-        $this->assertEquals(4, $database->count('movies', $queries));
+        // Test 5: Upsert - Bulk upsertDocuments (create and update)
+        $docId3 = 'json-doc-3';
+        $docId4 = 'json-doc-4';
 
-        $queries = [
-            Query::equal('active', [true]),
-            Query::or([
-                Query::equal('name', ['Frozen']),
-                Query::equal('name', ['Frozen II']),
-                Query::equal('director', ['Joe Johnston'])
-            ])
+        $bulkDocuments = [
+            new Document([
+                '$id' => $docId3,
+                'name' => 'Bulk Upsert 1',
+                'metadata' => [
+                    'version' => '3.0.0',
+                    'tags' => ['python', 'flask'],
+                    'config' => ['debug' => false],
+                ],
+                '$permissions' => $permissions,
+            ]),
+            new Document([
+                '$id' => $docId4,
+                'name' => 'Bulk Upsert 2',
+                'metadata' => [
+                    'version' => '3.1.0',
+                    'tags' => ['go', 'golang'],
+                    'config' => ['debug' => true],
+                ],
+                '$permissions' => $permissions,
+            ]),
+            // Update existing document
+            new Document([
+                '$id' => $docId1,
+                'name' => 'Bulk Updated Document',
+                'metadata' => [
+                    'version' => '3.0.0',
+                    'tags' => ['php', 'database', 'bulk'],
+                    'config' => [
+                        'debug' => false,
+                        'timeout' => 120,
+                    ],
+                    'bulkUpdated' => true,
+                ],
+                '$permissions' => $permissions,
+            ]),
         ];
 
-        $this->assertCount(3, $database->find('movies', $queries));
-        $this->assertEquals(3, $database->count('movies', $queries));
-    }
+        $count = $database->upsertDocuments($collection, $bulkDocuments);
+        $this->assertEquals(3, $count);
 
-    public function testOrNested(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify bulk upsert results
+        $bulkDoc1 = $database->getDocument($collection, $docId3);
+        $this->assertEquals('Bulk Upsert 1', $bulkDoc1->getAttribute('name'));
+        $this->assertEquals('3.0.0', $bulkDoc1->getArray('metadata')['version']);
 
-        $queries = [
-            Query::select(['director']),
-            Query::equal('director', ['Joe Johnston']),
-            Query::or([
-                Query::equal('name', ['Frozen']),
-                Query::or([
-                    Query::equal('active', [true]),
-                    Query::equal('active', [false]),
-                ])
-            ])
-        ];
+        $bulkDoc2 = $database->getDocument($collection, $docId4);
+        $this->assertEquals('Bulk Upsert 2', $bulkDoc2->getAttribute('name'));
+        $this->assertEquals('3.1.0', $bulkDoc2->getArray('metadata')['version']);
 
-        $documents = $database->find('movies', $queries);
-        $this->assertCount(1, $documents);
-        $this->assertArrayNotHasKey('name', $documents[0]);
+        $bulkDoc3 = $database->getDocument($collection, $docId1);
+        $this->assertEquals('Bulk Updated Document', $bulkDoc3->getAttribute('name'));
+        $bulkMetadata = $bulkDoc3->getArray('metadata');
+        $this->assertEquals('3.0.0', $bulkMetadata['version']);
+        $this->assertTrue($bulkMetadata['bulkUpdated']);
 
-        $count = $database->count('movies', $queries);
-        $this->assertEquals(1, $count);
+        // Cleanup
+        $database->deleteCollection($collection);
     }
 
-    public function testAndSingleQuery(): void
+    public function testFindRegex(): void
     {
         /** @var Database $database */
-        $database = $this->getDatabase();
+        $database = static::getDatabase();
 
-        try {
-            $database->find('movies', [
-                Query::and([
-                    Query::equal('active', [true])
-                ])
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Invalid query: And queries require at least two queries', $e->getMessage());
+        // Skip test if regex is not supported
+        if (! $database->getAdapter()->supports(Capability::Regex)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
         }
-    }
 
-    public function testAndMultipleQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $queries = [
-            Query::and([
-                Query::equal('active', [true]),
-                Query::equal('name', ['Frozen II'])
-            ])
-        ];
-        $this->assertCount(1, $database->find('movies', $queries));
-        $this->assertEquals(1, $database->count('movies', $queries));
-    }
-
-    public function testAndNested(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $queries = [
-            Query::or([
-                Query::equal('active', [false]),
-                Query::and([
-                    Query::equal('active', [true]),
-                    Query::equal('name', ['Frozen']),
-                ])
-            ])
-        ];
+        // Determine regex support type
+        $supportsPCRE = $database->getAdapter()->supports(Capability::PCRE);
+        $supportsPOSIX = $database->getAdapter()->supports(Capability::POSIX);
 
-        $documents = $database->find('movies', $queries);
-        $this->assertCount(3, $documents);
+        // Determine word boundary pattern based on support
+        $wordBoundaryPattern = null;
+        $wordBoundaryPatternPHP = null;
+        if ($supportsPCRE) {
+            $wordBoundaryPattern = '\\b'; // PCRE uses \b
+            $wordBoundaryPatternPHP = '\\b'; // PHP preg_match uses \b
+        } elseif ($supportsPOSIX) {
+            $wordBoundaryPattern = '\\y'; // POSIX uses \y
+            $wordBoundaryPatternPHP = '\\b'; // PHP preg_match still uses \b for verification
+        }
 
-        $count = $database->count('movies', $queries);
-        $this->assertEquals(3, $count);
-    }
+        $database->createCollection(new Collection(id: 'moviesRegex', permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]));
 
-    public function testNestedIDQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', Attribute::string(key: 'name', size: 128, required: true)));
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', Attribute::string(key: 'director', size: 128, required: true)));
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', Attribute::integer(key: 'year', required: true)));
+        }
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        if ($database->getAdapter()->supports(Capability::TrigramIndex)) {
+            $database->createIndex('moviesRegex', Index::trigram(key: 'trigram_name', attributes: ['name']));
+            $database->createIndex('moviesRegex', Index::trigram(key: 'trigram_director', attributes: ['director']));
+        }
 
-        $database->createCollection('movies_nested_id', permissions: [
-            Permission::create(Role::any()),
-            Permission::update(Role::users())
+        // Create test documents
+        $database->createDocuments('moviesRegex', [
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Frozen',
+                'director' => 'Chris Buck & Jennifer Lee',
+                'year' => 2013,
+            ]),
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Frozen II',
+                'director' => 'Chris Buck & Jennifer Lee',
+                'year' => 2019,
+            ]),
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Captain America: The First Avenger',
+                'director' => 'Joe Johnston',
+                'year' => 2011,
+            ]),
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Captain Marvel',
+                'director' => 'Anna Boden & Ryan Fleck',
+                'year' => 2019,
+            ]),
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Work in Progress',
+                'director' => 'TBD',
+                'year' => 2025,
+            ]),
+            new Document([
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::create(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any()),
+                ],
+                'name' => 'Work in Progress 2',
+                'director' => 'TBD',
+                'year' => 2026,
+            ]),
         ]);
 
-        $this->assertEquals(true, $database->createAttribute('movies_nested_id', 'name', Database::VAR_STRING, 128, true));
-
-        $database->createDocument('movies_nested_id', new Document([
-            '$id' => ID::custom('1'),
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'name' => '1',
-        ]));
+        // Helper function to verify regex query completeness
+        /**
+         * @param  list<Document>  $queryResults
+         */
+        $verifyRegexQuery = function (string $attribute, string $regexPattern, array $queryResults) use ($database): void {
+            /** @var list<Document> $queryResults */
+            // Convert database regex pattern to PHP regex format.
+            // POSIX-style word boundary (\y) is not supported by PHP PCRE, so map it to \b.
+            $normalizedPattern = str_replace('\y', '\b', $regexPattern);
+            $phpPattern = '/'.str_replace('/', '\/', $normalizedPattern).'/';
 
-        $database->createDocument('movies_nested_id', new Document([
-            '$id' => ID::custom('2'),
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'name' => '2',
-        ]));
+            // Get all documents to manually verify
+            $allDocuments = $database->find('moviesRegex');
 
-        $database->createDocument('movies_nested_id', new Document([
-            '$id' => ID::custom('3'),
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'name' => '3',
-        ]));
+            // Manually filter documents that match the pattern
+            $expectedMatches = [];
+            foreach ($allDocuments as $doc) {
+                $value = $doc->getAttribute($attribute);
+                $this->assertIsString($value);
+                if (preg_match($phpPattern, $value)) {
+                    $expectedMatches[] = $doc->getId();
+                }
+            }
 
-        $queries = [
-            Query::or([
-                Query::equal('$id', ["1"]),
-                Query::equal('$id', ["2"])
-            ])
-        ];
+            $actualMatches = [];
+            foreach ($queryResults as $result) {
+                $actualMatches[] = $result->getId();
+                $value = $result->getAttribute($attribute);
+                $this->assertIsString($value);
+                $this->assertTrue(
+                    (bool) preg_match($phpPattern, $value),
+                    "Document '{$result->getId()}' with {$attribute}='{$value}' should match pattern '{$regexPattern}'"
+                );
+            }
 
-        $documents = $database->find('movies_nested_id', $queries);
-        $this->assertCount(2, $documents);
+            // Verify all expected documents are returned (no missing)
+            sort($expectedMatches);
+            sort($actualMatches);
+            $this->assertEquals(
+                $expectedMatches,
+                $actualMatches,
+                "Query should return exactly the documents matching pattern '{$regexPattern}' on attribute '{$attribute}'"
+            );
+        };
 
-        // Make sure the query was not modified by reference
-        $this->assertEquals($queries[0]->getValues()[0]->getAttribute(), '$id');
+        // Test basic regex pattern - match movies starting with 'Captain'
+        // Note: Pattern format may vary by adapter (MongoDB uses regex strings, SQL uses REGEXP)
+        $pattern = '/^Captain/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '^Captain'),
+        ]);
 
-        $count = $database->count('movies_nested_id', $queries);
-        $this->assertEquals(2, $count);
-    }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '^Captain', $documents);
 
-    public function testFindNull(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify expected documents are included
+        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
+        $this->assertTrue(in_array('Captain America: The First Avenger', $names));
+        $this->assertTrue(in_array('Captain Marvel', $names));
 
-        $documents = $database->find('movies', [
-            Query::isNull('nullable'),
+        // Test regex pattern - match movies containing 'Frozen'
+        $pattern = '/Frozen/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'Frozen'),
         ]);
 
-        $this->assertEquals(5, count($documents));
-    }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', 'Frozen', $documents);
 
-    public function testFindNotNull(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Test regex pattern - match exact title 'Frozen'
+        $exactFrozenDocuments = $database->find('moviesRegex', [
+            Query::regex('name', '^Frozen$'),
+        ]);
+        $verifyRegexQuery('name', '^Frozen$', $exactFrozenDocuments);
+        $this->assertCount(1, $exactFrozenDocuments, 'Exact ^Frozen$ regex should return only one document');
+        // Verify expected documents are included
+        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
+        $this->assertTrue(in_array('Frozen', $names));
+        $this->assertTrue(in_array('Frozen II', $names));
 
-        $documents = $database->find('movies', [
-            Query::isNotNull('nullable'),
+        // Test regex pattern - match movies ending with 'Marvel'
+        $pattern = '/Marvel$/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'Marvel$'),
         ]);
 
-        $this->assertEquals(1, count($documents));
-    }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', 'Marvel$', $documents);
 
-    public function testFindStartsWith(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->assertEquals(1, count($documents)); // Only Captain Marvel
+        $this->assertEquals('Captain Marvel', $documents[0]->getAttribute('name'));
 
-        $documents = $database->find('movies', [
-            Query::startsWith('name', 'Work'),
+        // Test regex pattern - match movies with 'Work' in the name
+        $pattern = '/.*Work.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '.*Work.*'),
         ]);
 
-        $this->assertEquals(2, count($documents));
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '.*Work.*', $documents);
 
-        if ($this->getDatabase()->getAdapter() instanceof SQL) {
-            $documents = $database->find('movies', [
-                Query::startsWith('name', '%ork'),
-            ]);
-        } else {
-            $documents = $database->find('movies', [
-                Query::startsWith('name', '.*ork'),
-            ]);
-        }
-
-        $this->assertEquals(0, count($documents));
-    }
-
-    public function testFindStartsWithWords(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify expected documents are included
+        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
+        $this->assertTrue(in_array('Work in Progress', $names));
+        $this->assertTrue(in_array('Work in Progress 2', $names));
 
-        $documents = $database->find('movies', [
-            Query::startsWith('name', 'Work in Progress'),
+        // Test regex pattern - match movies with 'Buck' in director
+        $pattern = '/.*Buck.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('director', '.*Buck.*'),
         ]);
 
-        $this->assertEquals(2, count($documents));
-    }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('director', '.*Buck.*', $documents);
 
-    public function testFindEndsWith(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify expected documents are included
+        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
+        $this->assertTrue(in_array('Frozen', $names));
+        $this->assertTrue(in_array('Frozen II', $names));
 
-        $documents = $database->find('movies', [
-            Query::endsWith('name', 'Marvel'),
+        // Test regex with case pattern - adapters may be case-sensitive or case-insensitive
+        // MySQL/MariaDB REGEXP is case-insensitive by default, MongoDB is case-sensitive
+        $patternCaseSensitive = '/captain/';
+        $patternCaseInsensitive = '/captain/i';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'captain'), // lowercase
         ]);
 
-        $this->assertEquals(1, count($documents));
-    }
-
-    public function testFindNotContains(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify all returned documents match the pattern (case-insensitive check for verification)
+        foreach ($documents as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);            // Verify that returned documents contain 'captain' (case-insensitive check)
+            $this->assertTrue(
+                (bool) preg_match($patternCaseInsensitive, $name),
+                "Document '{$name}' should match pattern 'captain' (case-insensitive check)"
+            );
+        }
 
-        if (!$database->getAdapter()->getSupportForQueryContains()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        // Verify completeness: Check what the database actually returns
+        // Some adapters (MongoDB) are case-sensitive, others (MySQL/MariaDB) are case-insensitive
+        // We'll determine expected matches based on case-sensitive matching (pure regex behavior)
+        // If the adapter is case-insensitive, it will return more documents, which is fine
+        $allDocuments = $database->find('moviesRegex');
+        $expectedMatchesCaseSensitive = [];
+        $expectedMatchesCaseInsensitive = [];
+        foreach ($allDocuments as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            if (preg_match($patternCaseSensitive, $name)) {
+                $expectedMatchesCaseSensitive[] = $doc->getId();
+            }
+            if (preg_match($patternCaseInsensitive, $name)) {
+                $expectedMatchesCaseInsensitive[] = $doc->getId();
+            }
         }
 
-        // Test notContains with array attributes - should return documents that don't contain specified genres
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['comics'])
-        ]);
+        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+        sort($actualMatches);
 
-        $this->assertEquals(4, count($documents)); // All movies except the 2 with 'comics' genre
+        // The database might be case-sensitive (MongoDB) or case-insensitive (MySQL/MariaDB)
+        // Check which one matches the actual results
+        sort($expectedMatchesCaseSensitive);
+        sort($expectedMatchesCaseInsensitive);
 
-        // Test notContains with multiple values (AND logic - exclude documents containing ANY of these)
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['comics', 'kids']),
-        ]);
+        // Verify that actual results match either case-sensitive or case-insensitive expectations
+        $matchesCaseSensitive = ($expectedMatchesCaseSensitive === $actualMatches);
+        $matchesCaseInsensitive = ($expectedMatchesCaseInsensitive === $actualMatches);
 
-        $this->assertEquals(2, count($documents)); // Movies that have neither 'comics' nor 'kids'
+        $this->assertTrue(
+            $matchesCaseSensitive || $matchesCaseInsensitive,
+            'Query results should match either case-sensitive ('.count($expectedMatchesCaseSensitive).' docs) or case-insensitive ('.count($expectedMatchesCaseInsensitive).' docs) expectations. Got '.count($actualMatches).' documents.'
+        );
 
-        // Test notContains with non-existent genre - should return all documents
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['non-existent']),
+        // Test regex with case-insensitive pattern (if adapter supports it via flags)
+        // Test with uppercase to verify case sensitivity
+        $pattern = '/Captain/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'Captain'), // uppercase
         ]);
 
-        $this->assertEquals(6, count($documents));
-
-        // Test notContains with string attribute (substring search)
-        $documents = $database->find('movies', [
-            Query::notContains('name', ['Captain'])
-        ]);
-        $this->assertEquals(4, count($documents)); // All movies except those containing 'Captain'
+        // Verify all returned documents match the pattern
+        foreach ($documents as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $this->assertTrue(
+                (bool) preg_match($pattern, $name),
+                "Document '{$name}' should match pattern 'Captain'"
+            );
+        }
 
-        // Test notContains combined with other queries (AND logic)
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['comics']),
-            Query::greaterThan('year', 2000)
-        ]);
-        $this->assertLessThanOrEqual(4, count($documents)); // Subset of movies without 'comics' and after 2000
+        // Verify completeness
+        $allDocuments = $database->find('moviesRegex');
+        $expectedMatches = [];
+        foreach ($allDocuments as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            if (preg_match($pattern, $name)) {
+                $expectedMatches[] = $doc->getId();
+            }
+        }
+        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+        sort($expectedMatches);
+        sort($actualMatches);
+        $this->assertEquals(
+            $expectedMatches,
+            $actualMatches,
+            "Query should return exactly the documents matching pattern 'Captain'"
+        );
 
-        // Test notContains with case sensitivity
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['COMICS']) // Different case
+        // Test regex combined with other queries
+        $pattern = '/^Captain/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '^Captain'),
+            Query::greaterThan('year', 2010),
         ]);
-        $this->assertEquals(6, count($documents)); // All movies since case doesn't match
 
-        // Test error handling for invalid attribute type
-        try {
-            $database->find('movies', [
-                Query::notContains('price', [10.5]),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertEquals('Invalid query: Cannot query notContains on attribute "price" because it is not an array, string, or object.', $e->getMessage());
-            $this->assertTrue($e instanceof DatabaseException);
+        // Verify all returned documents match both conditions
+        foreach ($documents as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $year = $doc->getAttribute('year');
+            $this->assertTrue(
+                (bool) preg_match($pattern, $name),
+                "Document '{$name}' should match pattern '{$pattern}'"
+            );
+            $this->assertGreaterThan(2010, $year, "Document '{$name}' should have year > 2010");
         }
-    }
 
-    public function testFindNotSearch(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        // Only test if fulltext search is supported
-        if ($this->getDatabase()->getAdapter()->getSupportForFulltextIndex()) {
-            // Ensure fulltext index exists (may already exist from previous tests)
-            try {
-                $database->createIndex('movies', 'name', Database::INDEX_FULLTEXT, ['name']);
-            } catch (Throwable $e) {
-                // Index may already exist, ignore duplicate error
-                if (!str_contains($e->getMessage(), 'already exists')) {
-                    throw $e;
-                }
+        // Verify completeness: manually check all documents that match both conditions
+        $allDocuments = $database->find('moviesRegex');
+        $expectedMatches = [];
+        foreach ($allDocuments as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $year = $doc->getAttribute('year');
+            if (preg_match($pattern, $name) && $year > 2010) {
+                $expectedMatches[] = $doc->getId();
             }
+        }
+        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+        sort($expectedMatches);
+        sort($actualMatches);
+        $this->assertEquals(
+            $expectedMatches,
+            $actualMatches,
+            "Query should return exactly the documents matching both regex '^Captain' and year > 2010"
+        );
 
-            // Test notSearch - should return documents that don't match the search term
-            $documents = $database->find('movies', [
-                Query::notSearch('name', 'captain'),
-            ]);
-
-            $this->assertEquals(4, count($documents)); // All movies except the 2 with 'captain' in name
-
-            // Test notSearch with term that doesn't exist - should return all documents
-            $documents = $database->find('movies', [
-                Query::notSearch('name', 'nonexistent'),
-            ]);
+        // Test regex with limit
+        $pattern = '/.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '.*'), // Match all
+            Query::limit(3),
+        ]);
 
-            $this->assertEquals(6, count($documents));
+        $this->assertEquals(3, count($documents));
 
-            // Test notSearch with partial term
-            if ($this->getDatabase()->getAdapter()->getSupportForFulltextWildCardIndex()) {
-                $documents = $database->find('movies', [
-                    Query::notSearch('name', 'cap'),
-                ]);
+        // Verify all returned documents match the pattern (should match all)
+        foreach ($documents as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $this->assertTrue(
+                (bool) preg_match($pattern, $name),
+                "Document '{$name}' should match pattern '{$pattern}'"
+            );
+        }
 
-                $this->assertEquals(4, count($documents)); // All movies except those matching 'cap'
-            }
+        // Note: With limit, we can't verify completeness, but we can verify all returned match
 
-            // Test notSearch with empty string - should return all documents
-            $documents = $database->find('movies', [
-                Query::notSearch('name', ''),
-            ]);
-            $this->assertEquals(6, count($documents)); // All movies since empty search matches nothing
+        // Test regex with non-matching pattern
+        $pattern = '/^NonExistentPattern$/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '^NonExistentPattern$'),
+        ]);
 
-            // Test notSearch combined with other filters
-            $documents = $database->find('movies', [
-                Query::notSearch('name', 'captain'),
-                Query::lessThan('year', 2010)
-            ]);
-            $this->assertLessThanOrEqual(4, count($documents)); // Subset of non-captain movies before 2010
+        $this->assertEquals(0, count($documents));
 
-            // Test notSearch with special characters
-            $documents = $database->find('movies', [
-                Query::notSearch('name', '@#$%'),
-            ]);
-            $this->assertEquals(6, count($documents)); // All movies since special chars don't match
+        // Verify no documents match (double-check by getting all and filtering)
+        $allDocuments = $database->find('moviesRegex');
+        $matchingCount = 0;
+        foreach ($allDocuments as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            if (preg_match($pattern, $name)) {
+                $matchingCount++;
+            }
         }
+        $this->assertEquals(0, $matchingCount, "No documents should match pattern '{$pattern}'");
 
-        $this->assertEquals(true, true); // Test must do an assertion
-    }
-
-    public function testFindNotStartsWith(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify completeness: no documents should be returned
+        $this->assertEquals([], array_map(fn ($doc) => $doc->getId(), $documents));
 
-        // Test notStartsWith - should return documents that don't start with 'Work'
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'Work'),
+        // Test regex with special characters (should be escaped or handled properly)
+        $pattern = '/.*:.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '.*:.*'), // Match movies with colon
         ]);
 
-        $this->assertEquals(4, count($documents)); // All movies except the 2 starting with 'Work'
-
-        // Test notStartsWith with non-existent prefix - should return all documents
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'NonExistent'),
-        ]);
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '.*:.*', $documents);
 
-        $this->assertEquals(6, count($documents));
+        // Verify expected document is included
+        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
+        $this->assertTrue(in_array('Captain America: The First Avenger', $names));
 
-        // Test notStartsWith with wildcard characters (should treat them literally)
-        if ($this->getDatabase()->getAdapter() instanceof SQL) {
-            $documents = $database->find('movies', [
-                Query::notStartsWith('name', '%ork'),
-            ]);
-        } else {
-            $documents = $database->find('movies', [
-                Query::notStartsWith('name', '.*ork'),
+        // ReDOS safety: ensure pathological patterns respond quickly and do not hang
+        $catastrophicPattern = '(a+)+$';
+        $start = microtime(true);
+        $redosDocs = $database->find('moviesRegex', [
+            Query::regex('name', $catastrophicPattern),
+        ]);
+        $elapsed = microtime(true) - $start;
+        $this->assertLessThan(1.0, $elapsed, 'Regex evaluation should not be slow or vulnerable to ReDOS');
+        $verifyRegexQuery('name', $catastrophicPattern, $redosDocs);
+        $this->assertCount(0, $redosDocs, 'Pathological regex should not match any movie titles');
+
+        // Test regex search pattern - match movies with word boundaries
+        // Only test if word boundaries are supported (PCRE or POSIX)
+        if ($wordBoundaryPattern !== null) {
+            $dbPattern = $wordBoundaryPattern.'Work'.$wordBoundaryPattern;
+            $phpPattern = '/'.$wordBoundaryPatternPHP.'Work'.$wordBoundaryPatternPHP.'/';
+            $documents = $database->find('moviesRegex', [
+                Query::regex('name', $dbPattern),
             ]);
-        }
 
-        $this->assertEquals(6, count($documents)); // Should return all since no movie starts with these patterns
+            // Verify all returned documents match the pattern
+            foreach ($documents as $doc) {
+                $name = $doc->getAttribute('name');
+                $this->assertIsString($name);
+                $this->assertTrue(
+                    (bool) preg_match($phpPattern, $name),
+                    "Document '{$name}' should match pattern '{$dbPattern}'"
+                );
+            }
 
-        // Test notStartsWith with empty string - should return no documents (all strings start with empty)
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', ''),
-        ]);
-        $this->assertEquals(0, count($documents)); // No documents since all strings start with empty string
+            // Verify completeness: manually check all documents
+            $allDocuments = $database->find('moviesRegex');
+            $expectedMatches = [];
+            foreach ($allDocuments as $doc) {
+                $name = $doc->getAttribute('name');
+                $this->assertIsString($name);
+                if (preg_match($phpPattern, $name)) {
+                    $expectedMatches[] = $doc->getId();
+                }
+            }
+            $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+            sort($expectedMatches);
+            sort($actualMatches);
+            $this->assertEquals(
+                $expectedMatches,
+                $actualMatches,
+                "Query should return exactly the documents matching pattern '{$dbPattern}'"
+            );
+        }
 
-        // Test notStartsWith with single character
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'C'),
+        // Test regex search with multiple patterns - match movies containing 'Captain' or 'Frozen'
+        $pattern1 = '/Captain/';
+        $pattern2 = '/Frozen/';
+        $documents = $database->find('moviesRegex', [
+            Query::or([
+                Query::regex('name', 'Captain'),
+                Query::regex('name', 'Frozen'),
+            ]),
         ]);
-        $this->assertGreaterThanOrEqual(4, count($documents)); // Movies not starting with 'C'
 
-        // Test notStartsWith with case sensitivity (may be case-insensitive depending on DB)
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'work'), // lowercase vs 'Work'
-        ]);
-        $this->assertGreaterThanOrEqual(4, count($documents)); // May match case-insensitively
+        // Verify all returned documents match at least one pattern
+        foreach ($documents as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $matchesPattern1 = (bool) preg_match($pattern1, $name);
+            $matchesPattern2 = (bool) preg_match($pattern2, $name);
+            $this->assertTrue(
+                $matchesPattern1 || $matchesPattern2,
+                "Document '{$name}' should match either pattern 'Captain' or 'Frozen'"
+            );
+        }
 
-        // Test notStartsWith combined with other queries
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'Work'),
-            Query::equal('year', [2006])
-        ]);
-        $this->assertLessThanOrEqual(4, count($documents)); // Subset of non-Work movies from 2006
+        // Verify completeness: manually check all documents
+        $allDocuments = $database->find('moviesRegex');
+        $expectedMatches = [];
+        foreach ($allDocuments as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            if (preg_match($pattern1, $name) || preg_match($pattern2, $name)) {
+                $expectedMatches[] = $doc->getId();
+            }
+        }
+        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+        sort($expectedMatches);
+        sort($actualMatches);
+        $this->assertEquals(
+            $expectedMatches,
+            $actualMatches,
+            "Query should return exactly the documents matching pattern 'Captain' OR 'Frozen'"
+        );
+        $database->deleteCollection('moviesRegex');
     }
 
-    public function testFindNotEndsWith(): void
+    public function testRegexInjection(): void
     {
         /** @var Database $database */
-        $database = $this->getDatabase();
-
-        // Test notEndsWith - should return documents that don't end with 'Marvel'
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'Marvel'),
-        ]);
+        $database = static::getDatabase();
 
-        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'Marvel'
+        // Skip test if regex is not supported
+        if (! $database->getAdapter()->supports(Capability::Regex)) {
+            $this->expectNotToPerformAssertions();
 
-        // Test notEndsWith with non-existent suffix - should return all documents
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'NonExistent'),
-        ]);
+            return;
+        }
 
-        $this->assertEquals(6, count($documents));
+        $collectionName = 'injectionTest';
+        $database->createCollection(new Collection(id: $collectionName, permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]));
 
-        // Test notEndsWith with partial suffix
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'vel'),
-        ]);
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::string(key: 'text', size: 1000, required: true)));
+        }
 
-        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'vel' (from 'Marvel')
+        // Create test documents - one that should match, one that shouldn't
+        $database->createDocument($collectionName, new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'text' => 'target',
+        ]));
 
-        // Test notEndsWith with empty string - should return no documents (all strings end with empty)
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', ''),
-        ]);
-        $this->assertEquals(0, count($documents)); // No documents since all strings end with empty string
+        $database->createDocument($collectionName, new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'text' => 'other',
+        ]));
 
-        // Test notEndsWith with single character
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'l'),
-        ]);
-        $this->assertGreaterThanOrEqual(5, count($documents)); // Movies not ending with 'l'
+        // SQL injection attempts - these should NOT return the "other" document
+        $sqlInjectionPatterns = [
+            "target') OR '1'='1",           // SQL injection attempt
+            "target' OR 1=1--",            // SQL injection with comment
+            "target' OR 'x'='x",           // SQL injection attempt
+            "target' UNION SELECT *--",     // SQL UNION injection
+        ];
 
-        // Test notEndsWith with case sensitivity (may be case-insensitive depending on DB)
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'marvel'), // lowercase vs 'Marvel'
-        ]);
-        $this->assertGreaterThanOrEqual(5, count($documents)); // May match case-insensitively
+        // MongoDB injection attempts - these should NOT return the "other" document
+        $mongoInjectionPatterns = [
+            'target" || "1"=="1',          // MongoDB injection attempt
+            'target" || true',              // MongoDB boolean injection
+            'target"} || {"text": "other"}', // MongoDB operator injection
+        ];
 
-        // Test notEndsWith combined with limit
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'Marvel'),
-            Query::limit(3)
-        ]);
-        $this->assertEquals(3, count($documents)); // Limited to 3 results
-        $this->assertLessThanOrEqual(5, count($documents)); // But still excluding Marvel movies
-    }
+        $allInjectionPatterns = array_merge($sqlInjectionPatterns, $mongoInjectionPatterns);
 
-    public function testFindOrderRandom(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        foreach ($allInjectionPatterns as $pattern) {
+            try {
+                $results = $database->find($collectionName, [
+                    Query::regex('text', $pattern),
+                ]);
 
-        if (!$database->getAdapter()->getSupportForOrderRandom()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+                // Critical check: if injection succeeded, we might get the "other" document
+                // which should NOT match a pattern starting with "target"
+                $foundOther = false;
+                foreach ($results as $doc) {
+                    $text = $doc->getAttribute('text');
+                    $this->assertIsString($text);
+                    if ($text === 'other') {
+                        $foundOther = true;
 
-        // Test orderRandom with default limit
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(1),
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertNotEmpty($documents[0]['name']); // Ensure we got a valid document
+                        // Verify that "other" doesn't actually match the pattern as a regex
+                        $matches = @preg_match('/'.str_replace('/', '\/', $pattern).'/', $text);
+                        if ($matches === 0 || $matches === false) {
+                            // "other" doesn't match the pattern but was returned
+                            // This indicates potential injection vulnerability
+                            $this->fail(
+                                "Potential injection detected: Pattern '{$pattern}' returned document 'other' ".
+                                "which doesn't match the pattern. This suggests SQL/MongoDB injection may have succeeded."
+                            );
+                        }
+                    }
+                }
 
-        // Test orderRandom with multiple documents
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(3),
-        ]);
-        $this->assertEquals(3, count($documents));
+                // Additional verification: check that all returned documents actually match the pattern
+                foreach ($results as $doc) {
+                    $text = $doc->getAttribute('text');
+                    $this->assertIsString($text);
+                    $matches = @preg_match('/'.str_replace('/', '\/', $pattern).'/', $text);
 
-        // Test that orderRandom returns different results (not guaranteed but highly likely)
-        $firstSet = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(3),
-        ]);
-        $secondSet = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(3),
-        ]);
+                    // If pattern is invalid, skip validation
+                    if ($matches === false) {
+                        continue;
+                    }
 
-        // Extract IDs for comparison
-        $firstIds = array_map(fn ($doc) => $doc['$id'], $firstSet);
-        $secondIds = array_map(fn ($doc) => $doc['$id'], $secondSet);
+                    // If document doesn't match but was returned, it's suspicious
+                    if ($matches === 0) {
+                        $this->fail(
+                            "Potential injection: Document '{$text}' was returned for pattern '{$pattern}' ".
+                            "but doesn't match the regex pattern."
+                        );
+                    }
+                }
 
-        // While not guaranteed to be different, with 6 movies and selecting 3,
-        // the probability of getting the same set in the same order is very low
-        // We'll just check that we got valid results
-        $this->assertEquals(3, count($firstIds));
-        $this->assertEquals(3, count($secondIds));
+            } catch (\Exception $e) {
+                $this->assertNotSame('', $e->getMessage());
+            }
+        }
 
-        // Test orderRandom with more than available documents
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(10), // We only have 6 movies
-        ]);
-        $this->assertLessThanOrEqual(6, count($documents)); // Should return all available documents
-
-        // Test orderRandom with filters
-        $documents = $database->find('movies', [
-            Query::greaterThan('price', 10),
-            Query::orderRandom(),
-            Query::limit(2),
-        ]);
-        $this->assertLessThanOrEqual(2, count($documents));
-        foreach ($documents as $document) {
-            $this->assertGreaterThan(10, $document['price']);
-        }
-
-        // Test orderRandom without explicit limit (should use default)
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-        ]);
-        $this->assertGreaterThan(0, count($documents));
-        $this->assertLessThanOrEqual(25, count($documents)); // Default limit is 25
-    }
-
-    public function testFindNotBetween(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        // Test notBetween with price range - should return documents outside the range
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 25.94, 25.99),
-        ]);
-        $this->assertEquals(4, count($documents)); // All movies except the 2 in the price range
-
-        // Test notBetween with range that includes no documents - should return all documents
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 30, 35),
-        ]);
-        $this->assertEquals(6, count($documents));
-
-        // Test notBetween with date range
-        $documents = $database->find('movies', [
-            Query::notBetween('$createdAt', '1975-12-06', '2050-12-06'),
-        ]);
-        $this->assertEquals(0, count($documents)); // No movies outside this wide date range
-
-        // Test notBetween with narrower date range
-        $documents = $database->find('movies', [
-            Query::notBetween('$createdAt', '2000-01-01', '2001-01-01'),
-        ]);
-        $this->assertEquals(6, count($documents)); // All movies should be outside this narrow range
-
-        // Test notBetween with updated date range
-        $documents = $database->find('movies', [
-            Query::notBetween('$updatedAt', '2000-01-01T00:00:00.000+00:00', '2001-01-01T00:00:00.000+00:00'),
-        ]);
-        $this->assertEquals(6, count($documents)); // All movies should be outside this narrow range
-
-        // Test notBetween with year range (integer values)
-        $documents = $database->find('movies', [
-            Query::notBetween('year', 2005, 2007),
-        ]);
-        $this->assertLessThanOrEqual(6, count($documents)); // Movies outside 2005-2007 range
-
-        // Test notBetween with reversed range (start > end) - should still work
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 25.99, 25.94), // Note: reversed order
-        ]);
-        $this->assertGreaterThanOrEqual(4, count($documents)); // Should handle reversed range gracefully
-
-        // Test notBetween with same start and end values
-        $documents = $database->find('movies', [
-            Query::notBetween('year', 2006, 2006),
-        ]);
-        $this->assertGreaterThanOrEqual(5, count($documents)); // All movies except those from exactly 2006
-
-        // Test notBetween combined with other filters
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 25.94, 25.99),
-            Query::orderDesc('year'),
-            Query::limit(2)
-        ]);
-        $this->assertEquals(2, count($documents)); // Limited results, ordered, excluding price range
-
-        // Test notBetween with extreme ranges
-        $documents = $database->find('movies', [
-            Query::notBetween('year', -1000, 1000), // Very wide range
-        ]);
-        $this->assertLessThanOrEqual(6, count($documents)); // Movies outside this range
-
-        // Test notBetween with float precision
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 25.945, 25.955), // Very narrow range
-        ]);
-        $this->assertGreaterThanOrEqual(4, count($documents)); // Most movies should be outside this narrow range
-    }
-
-    public function testFindSelect(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
-
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$id'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
-
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$sequence'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
-
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$collection'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
-
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$createdAt'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
+        // Test that legitimate regex patterns still work correctly
+        $legitimatePatterns = [
+            'target',      // Should match "target"
+            '^target',     // Should match "target" (anchored)
+            'other',       // Should match "other"
+        ];
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$updatedAt'])
-        ]);
+        foreach ($legitimatePatterns as $pattern) {
+            try {
+                $results = $database->find($collectionName, [
+                    Query::regex('text', $pattern),
+                ]);
 
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+                // Verify each result actually matches
+                foreach ($results as $doc) {
+                    $text = $doc->getAttribute('text');
+                    $this->assertIsString($text);
+                    $matches = @preg_match('/'.str_replace('/', '\/', $pattern).'/', $text);
+                    if ($matches !== false) {
+                        $this->assertEquals(
+                            1,
+                            $matches,
+                            "Document '{$text}' should match pattern '{$pattern}'"
+                        );
+                    }
+                }
+            } catch (\Exception $e) {
+                $this->fail("Legitimate pattern '{$pattern}' should not throw exception: ".$e->getMessage());
+            }
         }
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$permissions'])
-        ]);
-
-        foreach ($documents as $document) {
-            $this->assertArrayHasKey('name', $document);
-            $this->assertArrayHasKey('year', $document);
-            $this->assertArrayNotHasKey('director', $document);
-            $this->assertArrayNotHasKey('price', $document);
-            $this->assertArrayNotHasKey('active', $document);
-            $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
-            $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
-        }
+        // Cleanup
+        $database->deleteCollection($collectionName);
     }
 
-    /** @depends testFind */
-    public function testForeach(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * Test, foreach generator on empty collection
-         */
-        $database->createCollection('moviesEmpty');
-        $documents = [];
-        foreach ($database->iterate('moviesEmpty', queries: [Query::limit(2)]) as $document) {
-            $documents[] = $document;
-        }
-        $this->assertEquals(0, \count($documents));
-        $this->assertTrue($database->deleteCollection('moviesEmpty'));
-
-        /**
-         * Test, foreach generator
-         */
-        $documents = [];
-        foreach ($database->iterate('movies', queries: [Query::limit(2)]) as $document) {
-            $documents[] = $document;
-        }
-        $this->assertEquals(6, count($documents));
-
-        /**
-         * Test, foreach goes through all the documents
-         */
-        $documents = [];
-        $database->foreach('movies', queries: [Query::limit(2)], callback: function ($document) use (&$documents) {
-            $documents[] = $document;
-        });
-        $this->assertEquals(6, count($documents));
+    /**
+     * Test ReDoS (Regular Expression Denial of Service) with timeout protection
+     * This test verifies that ReDoS patterns either timeout properly or complete quickly,
+     * preventing denial of service attacks.
+     */
+    //    public function testRegexRedos(): void
+    //    {
+    //        /** @var Database $database */
+    //        $database = static::getDatabase();
+    //
+    //        // Skip test if regex is not supported
+    //        if (!$database->getAdapter()->supports(Capability::Regex)) {
+    //            $this->expectNotToPerformAssertions();
+    //            return;
+    //        }
+    //
+    //        $collectionName = 'redosTimeoutTest';
+    //        $database->createCollection($collectionName, permissions: [
+    //            Permission::create(Role::any()),
+    //            Permission::read(Role::any()),
+    //            Permission::update(Role::any()),
+    //            Permission::delete(Role::any()),
+    //        ]);
+    //
+    //        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+    //            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::string(key: 'text', size: 1000, required: true)));
+    //        }
+    //
+    //        // Create documents with strings designed to trigger ReDoS
+    //        // These strings have many 'a's but end with 'c' instead of 'b'
+    //        // This causes catastrophic backtracking with patterns like (a+)+b
+    //        $redosStrings = [];
+    //        for ($i = 15; $i <= 35; $i += 5) {
+    //            $redosStrings[] = str_repeat('a', $i) . 'c';
+    //        }
+    //
+    //        // Also add some normal strings
+    //        $normalStrings = [
+    //            'normal text',
+    //            'another string',
+    //            'test123',
+    //            'valid data',
+    //        ];
+    //
+    //        $documents = [];
+    //        foreach ($redosStrings as $text) {
+    //            $documents[] = new Document([
+    //                '$permissions' => [
+    //                    Permission::read(Role::any()),
+    //                    Permission::create(Role::any()),
+    //                    Permission::update(Role::any()),
+    //                    Permission::delete(Role::any()),
+    //                ],
+    //                'text' => $text,
+    //            ]);
+    //        }
+    //
+    //        foreach ($normalStrings as $text) {
+    //            $documents[] = new Document([
+    //                '$permissions' => [
+    //                    Permission::read(Role::any()),
+    //                    Permission::create(Role::any()),
+    //                    Permission::update(Role::any()),
+    //                    Permission::delete(Role::any()),
+    //                ],
+    //                'text' => $text,
+    //            ]);
+    //        }
+    //
+    //        $database->createDocuments($collectionName, $documents);
+    //
+    //        // ReDoS patterns that cause exponential backtracking
+    //        $redosPatterns = [
+    //            '(a+)+b',      // Classic ReDoS: nested quantifiers
+    //            '(a|a)*b',     // Alternation with quantifier
+    //            '(a+)+$',      // Anchored pattern
+    //            '(a*)*b',      // Nested star quantifiers
+    //            '(a+)+b+',     // Multiple nested quantifiers
+    //            '(.+)+b',      // Generic nested quantifiers
+    //            '(.*)+b',      // Generic nested quantifiers
+    //        ];
+    //
+    //        $supportsTimeout = ($database->getAdapter()->hasFeature(Feature\Timeouts::class));
+    //
+    //        if ($supportsTimeout) {
+    //            $database->setTimeout(2000);
+    //        }
+    //
+    //        foreach ($redosPatterns as $pattern) {
+    //            $startTime = microtime(true);
+    //
+    //            try {
+    //                $results = $database->find($collectionName, [
+    //                    Query::regex('text', $pattern),
+    //                ]);
+    //                $elapsed = microtime(true) - $startTime;
+    //                // If timeout is supported, the query should either:
+    //                // 1. Complete quickly (< 3 seconds) if ReDoS is mitigated
+    //                // 2. Throw TimeoutException if it takes too long
+    //                if ($supportsTimeout) {
+    //                    // If we got here without timeout, it should have completed quickly
+    //                    $this->assertLessThan(
+    //                        3.0,
+    //                        $elapsed,
+    //                        "Regex pattern '{$pattern}' should complete quickly or timeout. Took {$elapsed}s"
+    //                    );
+    //                } else {
+    //                    // Without timeout support, we just check it doesn't hang forever
+    //                    // Set a reasonable upper bound (15 seconds) for systems without timeout
+    //                    $this->assertLessThan(
+    //                        15.0,
+    //                        $elapsed,
+    //                        "Regex pattern '{$pattern}' should not cause excessive delay. Took {$elapsed}s"
+    //                    );
+    //                }
+    //
+    //                // Verify results: none of our ReDoS strings should match these patterns
+    //                // (they all end with 'c', not 'b')
+    //                foreach ($results as $doc) {
+    //                    $text = $doc->getAttribute('text');
+    //                    // If it matched, verify it's actually a valid match
+    //                    $matches = @preg_match('/' . str_replace('/', '\/', $pattern) . '/', $text);
+    //                    if ($matches !== false) {
+    //                        $this->assertEquals(
+    //                            1,
+    //                            $matches,
+    //                            "Document with text '{$text}' should actually match pattern '{$pattern}'"
+    //                        );
+    //                    }
+    //                }
+    //
+    //            } catch (TimeoutException $e) {
+    //                // Timeout is expected for ReDoS patterns if not properly mitigated
+    //                $elapsed = microtime(true) - $startTime;
+    //                $this->assertInstanceOf(
+    //                    TimeoutException::class,
+    //                    $e,
+    //                    "Regex pattern '{$pattern}' should timeout if it causes ReDoS. Elapsed: {$elapsed}s"
+    //                );
+    //
+    //                // Timeout should happen within reasonable time (not immediately, but not too late)
+    //                // Fast timeouts are actually good - they mean the system is protecting itself quickly
+    //                $this->assertGreaterThan(
+    //                    0.05,
+    //                    $elapsed,
+    //                    "Timeout should occur after some minimal processing time"
+    //                );
+    //
+    //                // Timeout should happen before the timeout limit (with some buffer)
+    //                if ($supportsTimeout) {
+    //                    $this->assertLessThan(
+    //                        5.0,
+    //                        $elapsed,
+    //                        "Timeout should occur within reasonable time (before 5 seconds)"
+    //                    );
+    //                }
+    //
+    //            } catch (\Exception $e) {
+    //                // Check if this is a query interruption/timeout from MySQL (error 1317)
+    //                // MySQL sometimes throws "Query execution was interrupted" instead of TimeoutException
+    //                $message = $e->getMessage();
+    //                $isQueryInterrupted = false;
+    //
+    //                // Check message for interruption keywords
+    //                if (strpos($message, 'Query execution was interrupted') !== false ||
+    //                    strpos($message, 'interrupted') !== false) {
+    //                    $isQueryInterrupted = true;
+    //                }
+    //
+    //                // Check if it's a PDOException with error code 1317
+    //                if ($e instanceof PDOException) {
+    //                    $errorInfo = $e->errorInfo ?? [];
+    //                    // Error 1317 is "Query execution was interrupted"
+    //                    if (isset($errorInfo[1]) && $errorInfo[1] === 1317) {
+    //                        $isQueryInterrupted = true;
+    //                    }
+    //                    // Also check SQLSTATE 70100
+    //                    if ($e->getCode() === '70100') {
+    //                        $isQueryInterrupted = true;
+    //                    }
+    //                }
+    //
+    //                if ($isQueryInterrupted) {
+    //                    // This is effectively a timeout - MySQL interrupted the query
+    //                    $elapsed = microtime(true) - $startTime;
+    //                    $this->assertGreaterThan(
+    //                        0.05,
+    //                        $elapsed,
+    //                        "Query interruption should occur after some minimal processing time"
+    //                    );
+    //                    // This is acceptable - the query was interrupted due to timeout
+    //                    continue;
+    //                }
+    //
+    //                // Other exceptions are unexpected
+    //                $this->fail("Unexpected exception for pattern '{$pattern}': " . get_class($e) . " - " . $e->getMessage());
+    //            }
+    //        }
+    //
+    //        // Test with a pattern that should match quickly (not ReDoS)
+    //        $safePattern = 'normal';
+    //        $startTime = microtime(true);
+    //        $results = $database->find($collectionName, [
+    //            Query::regex('text', $safePattern),
+    //        ]);
+    //        $elapsed = microtime(true) - $startTime;
+    //
+    //        // Safe patterns should complete very quickly
+    //        $this->assertLessThan(1.0, $elapsed, 'Safe regex pattern should complete quickly');
+    //        $this->assertGreaterThan(0, count($results), 'Safe pattern should match some documents');
+    //
+    //        // Verify safe pattern results are correct
+    //        foreach ($results as $doc) {
+    //            $text = $doc->getAttribute('text');
+    //            $this->assertStringContainsString('normal', $text, "Document '{$text}' should contain 'normal'");
+    //        }
+    //
+    //        // Cleanup
+    //        if ($supportsTimeout) {
+    //            $database->clearTimeout();
+    //        }
+    //        $database->deleteCollection($collectionName);
+    //    }
 
-        /**
-         * Test, foreach with initial cursor
-         */
+    public function testNonUtfChars(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $first = $documents[0];
-        $documents = [];
-        $database->foreach('movies', queries: [Query::limit(2), Query::cursorAfter($first)], callback: function ($document) use (&$documents) {
-            $documents[] = $document;
-        });
-        $this->assertEquals(5, count($documents));
+        if (!$database->getAdapter()->getSupportNonUtfCharacters()) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        /**
-         * Test, foreach with initial offset
-         */
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, Attribute::string(key: 'title', size: 128, required: true)));
 
-        $documents = [];
-        $database->foreach('movies', queries: [Query::limit(2), Query::offset(2)], callback: function ($document) use (&$documents) {
-            $documents[] = $document;
-        });
-        $this->assertEquals(4, count($documents));
+        $nonUtfString = "Hello\x00World\xC3\x28\xFF\xFE\xA0Test\x00End";
 
-        /**
-         * Test, cursor before throws error
-         */
         try {
-            $database->foreach('movies', queries: [Query::cursorBefore($documents[0]), Query::offset(2)], callback: function ($document) use (&$documents) {
-                $documents[] = $document;
-            });
-
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertEquals('Cursor ' . Database::CURSOR_BEFORE . ' not supported in this method.', $e->getMessage());
-        }
+            $database->createDocument(__FUNCTION__, new Document([
+                'title' => $nonUtfString,
+            ]));
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertTrue($e instanceof CharacterException);
+        }
+
+        /**
+         * Convert to UTF-8 and replace invalid bytes with empty string
+         */
+        $nonUtfString = mb_convert_encoding($nonUtfString, 'UTF-8', 'UTF-8');
+
+        /**
+         * Remove null bytes
+         */
+        $nonUtfString = str_replace("\0", '', $nonUtfString);
+
+        $document = $database->createDocument(__FUNCTION__, new Document([
+            'title' => $nonUtfString,
+        ]));
 
+        $this->assertFalse($document->isEmpty());
+        $this->assertEquals('HelloWorld?(???TestEnd', $document->getAttribute('title'));
     }
 
-    /**
-     * @depends testFind
-     */
-    public function testCount(): void
+    public function testCreateDocumentNumericalId(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $count = $database->count('movies');
-        $this->assertEquals(6, $count);
-        $count = $database->count('movies', [Query::equal('year', [2019])]);
-
-        $this->assertEquals(2, $count);
-        $count = $database->count('movies', [Query::equal('with-dash', ['Works'])]);
-        $this->assertEquals(2, $count);
-        $count = $database->count('movies', [Query::equal('with-dash', ['Works2', 'Works3'])]);
-        $this->assertEquals(4, $count);
+        $database->createCollection(new Collection(id: 'numericalIds'));
 
-        $this->getDatabase()->getAuthorization()->removeRole('user:x');
-        $count = $database->count('movies');
-        $this->assertEquals(5, $count);
+        $this->assertEquals(true, $database->createAttribute('numericalIds', Attribute::string(key: 'name', size: 128, required: true)));
 
-        $this->getDatabase()->getAuthorization()->disable();
-        $count = $database->count('movies');
-        $this->assertEquals(6, $count);
-        $this->getDatabase()->getAuthorization()->reset();
+        // Test creating a document with an entirely numerical ID
+        $numericalIdDocument = $database->createDocument('numericalIds', new Document([
+            '$id' => '123456789',
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+            'name' => 'Test Document with Numerical ID',
+        ]));
 
-        $this->getDatabase()->getAuthorization()->disable();
-        $count = $database->count('movies', [], 3);
-        $this->assertEquals(3, $count);
-        $this->getDatabase()->getAuthorization()->reset();
+        $this->assertNotSame('', $numericalIdDocument->getId());
+        $this->assertEquals('123456789', $numericalIdDocument->getId());
+        $this->assertEquals('Test Document with Numerical ID', $numericalIdDocument->getAttribute('name'));
 
-        /**
-         * Test that OR queries are handled correctly
-         */
-        $this->getDatabase()->getAuthorization()->disable();
-        $count = $database->count('movies', [
-            Query::equal('director', ['TBD', 'Joe Johnston']),
-            Query::equal('year', [2025]),
-        ]);
-        $this->assertEquals(1, $count);
-        $this->getDatabase()->getAuthorization()->reset();
+        // Verify we can retrieve the document
+        $retrievedDocument = $database->getDocument('numericalIds', '123456789');
+        $this->assertNotSame('', $retrievedDocument->getId());
+        $this->assertEquals('123456789', $retrievedDocument->getId());
+        $this->assertEquals('Test Document with Numerical ID', $retrievedDocument->getAttribute('name'));
     }
 
-    /**
-     * @depends testFind
-     */
-    public function testSum(): void
+    public function testSkipPermissions(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->getDatabase()->getAuthorization()->addRole('user:x');
+        if (!($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $sum = $database->sum('movies', 'year', [Query::equal('year', [2019]),]);
-        $this->assertEquals(2019 + 2019, $sum);
-        $sum = $database->sum('movies', 'year');
-        $this->assertEquals(2013 + 2019 + 2011 + 2019 + 2025 + 2026, $sum);
-        $sum = $database->sum('movies', 'price', [Query::equal('year', [2019]),]);
-        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
-        $sum = $database->sum('movies', 'price', [Query::equal('year', [2019]),]);
-        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::integer(key: 'number'));
 
-        $sum = $database->sum('movies', 'year', [Query::equal('year', [2019])], 1);
-        $this->assertEquals(2019, $sum);
+        $data = [];
+        for ($i = 1; $i <= 10; $i++) {
+            $data[] = [
+                '$id' => "$i",
+                'number' => $i,
+            ];
+        }
 
-        $this->getDatabase()->getAuthorization()->removeRole('user:x');
+        $documents = array_map(fn ($d) => new Document($d), $data);
 
-        $sum = $database->sum('movies', 'year', [Query::equal('year', [2019]),]);
-        $this->assertEquals(2019 + 2019, $sum);
-        $sum = $database->sum('movies', 'year');
-        $this->assertEquals(2013 + 2019 + 2011 + 2019 + 2025, $sum);
-        $sum = $database->sum('movies', 'price', [Query::equal('year', [2019]),]);
-        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
-        $sum = $database->sum('movies', 'price', [Query::equal('year', [2019]),]);
-        $this->assertEquals(round(39.50 + 25.99, 2), round($sum, 2));
+        $results = [];
+        $count = $database->createDocuments(__FUNCTION__, $documents, onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+        });
+
+        $this->assertEquals($count, \count($results));
+        $this->assertEquals(10, \count($results));
+
+        /**
+         * Update 1 row
+         */
+        $data[\array_key_last($data)]['number'] = 100;
+
+        /**
+         * Add 1 row
+         */
+        $data[] = [
+            '$id' => "101",
+            'number' => 101,
+        ];
+
+        $documents = array_map(fn ($d) => new Document($d), $data);
+
+        $this->getDatabase()->getAuthorization()->disable();
+
+        $results = [];
+        $count = $database->upsertDocuments(
+            __FUNCTION__,
+            $documents,
+            onNext: function ($doc) use (&$results) {
+                $results[] = $doc;
+            }
+        );
+
+        $this->getDatabase()->getAuthorization()->reset();
+
+        $this->assertEquals(2, \count($results));
+        $this->assertEquals(2, $count);
+
+        foreach ($results as $result) {
+            $this->assertArrayHasKey('$permissions', $result);
+            $this->assertEquals([], $result->getAttribute('$permissions'));
+        }
     }
 
-    public function testIntegersBeyondInt32(): void
+    public function testUpsertDocumentsAttributeMismatch(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection(__FUNCTION__, attributes: [
-            new Document([
-                '$id' => 'amount',
-                'type' => Database::VAR_INTEGER,
-                'size' => 8,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => 'amounts',
-                'type' => Database::VAR_INTEGER,
-                'size' => 8,
-                'required' => true,
-                'signed' => true,
-                'array' => true,
-                'filters' => [],
-            ]),
-        ], permissions: [
-            Permission::read(Role::any()),
+        if (!($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $database->createCollection(new Collection(id: __FUNCTION__, permissions: [
             Permission::create(Role::any()),
-        ], documentSecurity: false);
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'first', size: 128, required: true));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'last', size: 128));
 
-        // Small values encode as int32, large ones as int64. Mongo hands the
-        // latter back wrapped, so both widths have to appear in one row.
-        $database->createDocument(__FUNCTION__, new Document([
-            '$id' => 'row1',
-            'amount' => 2000000000,
-            'amounts' => [-3408048000, -42, 3408048000, Database::MAX_BIG_INT],
-        ]));
-        $database->createDocument(__FUNCTION__, new Document([
-            '$id' => 'row2',
-            'amount' => 2000000000,
-            'amounts' => [-42],
+        $existingDocument = $database->createDocument(__FUNCTION__, new Document([
+            '$id' => 'first',
+            'first' => 'first',
+            'last' => 'last',
         ]));
 
-        foreach (['getDocument' => $database->getDocument(__FUNCTION__, 'row1'), 'find' => $database->find(__FUNCTION__, [Query::equal('$id', ['row1'])])[0]] as $path => $document) {
-            $this->assertIsInt($document->getAttribute('amount'), $path . ' returned a non-int scalar');
+        $newDocument = new Document([
+            '$id' => 'second',
+            'first' => 'second',
+        ]);
 
-            $amounts = $document->getAttribute('amounts');
-            foreach ($amounts as $index => $amount) {
-                $this->assertIsInt($amount, $path . ' returned a non-int at amounts[' . $index . ']');
-            }
+        // Ensure missing optionals on new document is allowed
+        $docs = $database->upsertDocuments(__FUNCTION__, [
+            $existingDocument->setAttribute('first', 'updated'),
+            $newDocument,
+        ]);
 
-            $this->assertSame([-3408048000, -42, 3408048000, Database::MAX_BIG_INT], $amounts);
+        $this->assertEquals(2, $docs);
+        $this->assertEquals('updated', $existingDocument->getAttribute('first'));
+        $this->assertEquals('last', $existingDocument->getAttribute('last'));
+        $this->assertEquals('second', $newDocument->getAttribute('first'));
+        $this->assertEquals('', $newDocument->getAttribute('last'));
 
-            // An Int64 wrapper survives assertSame above but serialises as
-            // {"$numberLong":"..."}, which is what reaches an API client.
-            $this->assertSame(
-                '{"amount":2000000000,"amounts":[-3408048000,-42,3408048000,' . Database::MAX_BIG_INT . ']}',
-                \json_encode([
-                    'amount' => $document->getAttribute('amount'),
-                    'amounts' => $amounts,
-                ]),
-                $path . ' did not serialise as plain JSON numbers'
-            );
+        try {
+            $database->upsertDocuments(__FUNCTION__, [
+                $existingDocument->removeAttribute('first'),
+                $newDocument
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+                $this->assertTrue($e instanceof StructureException, $e->getMessage());
+            }
         }
 
-        // sum() declares float|int, so a total past int32 is a return type
-        // violation unless the adapter hands back a native integer.
-        $sum = $database->sum(__FUNCTION__, 'amount');
-        $this->assertIsInt($sum);
-        $this->assertSame(4000000000, $sum);
+        // Ensure missing optionals on existing document is allowed
+        $docs = $database->upsertDocuments(__FUNCTION__, [
+            $existingDocument
+                ->setAttribute('first', 'first')
+                ->removeAttribute('last'),
+            $newDocument
+                ->setAttribute('last', 'last')
+        ]);
+
+        $this->assertEquals(2, $docs);
+        $this->assertEquals('first', $existingDocument->getAttribute('first'));
+        $this->assertEquals('last', $existingDocument->getAttribute('last'));
+        $this->assertEquals('second', $newDocument->getAttribute('first'));
+        $this->assertEquals('last', $newDocument->getAttribute('last'));
+
+        // Ensure set null on existing document is allowed
+        $docs = $database->upsertDocuments(__FUNCTION__, [
+            $existingDocument
+                ->setAttribute('first', 'first')
+                ->setAttribute('last', null),
+            $newDocument
+                ->setAttribute('last', 'last')
+        ]);
+
+        $this->assertEquals(1, $docs);
+        $this->assertEquals('first', $existingDocument->getAttribute('first'));
+        $this->assertEquals(null, $existingDocument->getAttribute('last'));
+        $this->assertEquals('second', $newDocument->getAttribute('first'));
+        $this->assertEquals('last', $newDocument->getAttribute('last'));
+
+        $doc3 = new Document([
+            '$id' => 'third',
+            'last' => 'last',
+            'first' => 'third',
+        ]);
+
+        $doc4 = new Document([
+            '$id' => 'fourth',
+            'first' => 'fourth',
+            'last' => 'last',
+        ]);
+
+        // Ensure mismatch of attribute orders is allowed
+        $docs = $database->upsertDocuments(__FUNCTION__, [
+            $doc3,
+            $doc4
+        ]);
+
+        $this->assertEquals(2, $docs);
+        $this->assertEquals('third', $doc3->getAttribute('first'));
+        $this->assertEquals('last', $doc3->getAttribute('last'));
+        $this->assertEquals('fourth', $doc4->getAttribute('first'));
+        $this->assertEquals('last', $doc4->getAttribute('last'));
+
+        $doc3 = $database->getDocument(__FUNCTION__, 'third');
+        $doc4 = $database->getDocument(__FUNCTION__, 'fourth');
+
+        $this->assertEquals('third', $doc3->getAttribute('first'));
+        $this->assertEquals('last', $doc3->getAttribute('last'));
+        $this->assertEquals('fourth', $doc4->getAttribute('first'));
+        $this->assertEquals('last', $doc4->getAttribute('last'));
     }
 
-    public function testEncodeDecode(): void
+    public function testUpsertDocumentsNoop(): void
     {
-        $collection = new Document([
-            '$collection' => ID::custom(Database::METADATA),
-            '$id' => ID::custom('users'),
-            'name' => 'Users',
-            'attributes' => [
-                [
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 256,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('email'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 1024,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('status'),
-                    'type' => Database::VAR_INTEGER,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('password'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 16384,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('passwordUpdate'),
-                    'type' => Database::VAR_DATETIME,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['datetime'],
-                ],
-                [
-                    '$id' => ID::custom('registration'),
-                    'type' => Database::VAR_DATETIME,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['datetime'],
-                ],
-                [
-                    '$id' => ID::custom('emailVerification'),
-                    'type' => Database::VAR_BOOLEAN,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('reset'),
-                    'type' => Database::VAR_BOOLEAN,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('prefs'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 16384,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['json']
-                ],
-                [
-                    '$id' => ID::custom('sessions'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 16384,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['json'],
-                ],
-                [
-                    '$id' => ID::custom('tokens'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 16384,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['json'],
-                ],
-                [
-                    '$id' => ID::custom('memberships'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 16384,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => false,
-                    'filters' => ['json'],
-                ],
-                [
-                    '$id' => ID::custom('roles'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 128,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => true,
-                    'filters' => [],
-                ],
-                [
-                    '$id' => ID::custom('tags'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 128,
-                    'signed' => true,
-                    'required' => false,
-                    'array' => true,
-                    'filters' => ['json'],
-                ],
-            ],
-            'indexes' => [
-                [
-                    '$id' => ID::custom('_key_email'),
-                    'type' => Database::INDEX_UNIQUE,
-                    'attributes' => ['email'],
-                    'lengths' => [1024],
-                    'orders' => [Database::ORDER_ASC],
-                ]
-            ],
-        ]);
+        if (!($this->getDatabase()->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->getDatabase()->createCollection(new Collection(id: __FUNCTION__));
+        $this->getDatabase()->createAttribute(__FUNCTION__, Attribute::string(key: 'string', size: 128, required: true));
 
         $document = new Document([
-            '$id' => ID::custom('608fdbe51361a'),
+            '$id' => 'first',
+            'string' => 'text📝',
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::create(Role::user('608fdbe51361a')),
-                Permission::update(Role::user('608fdbe51361a')),
-                Permission::delete(Role::user('608fdbe51361a')),
-            ],
-            'email' => 'test@example.com',
-            'emailVerification' => false,
-            'status' => 1,
-            'password' => 'randomhash',
-            'passwordUpdate' => '2000-06-12 14:12:55',
-            'registration' => '1975-06-12 14:12:55+01:00',
-            'reset' => false,
-            'name' => 'My Name',
-            'prefs' => new \stdClass(),
-            'sessions' => [],
-            'tokens' => [],
-            'memberships' => [],
-            'roles' => [
-                'admin',
-                'developer',
-                'tester',
-            ],
-            'tags' => [
-                ['$id' => '1', 'label' => 'x'],
-                ['$id' => '2', 'label' => 'y'],
-                ['$id' => '3', 'label' => 'z'],
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
             ],
         ]);
 
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
+        $this->assertEquals(1, $count);
 
-        $result = $database->encode($collection, $document);
+        // No changes, should return 0
+        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
+        $this->assertEquals(0, $count);
+    }
 
-        $this->assertEquals('608fdbe51361a', $result->getAttribute('$id'));
-        $this->assertContains('read("any")', $result->getAttribute('$permissions'));
-        $this->assertContains('read("any")', $result->getPermissions());
-        $this->assertContains('any', $result->getRead());
-        $this->assertContains(Permission::create(Role::user(ID::custom('608fdbe51361a'))), $result->getPermissions());
-        $this->assertContains('user:608fdbe51361a', $result->getCreate());
-        $this->assertContains('user:608fdbe51361a', $result->getWrite());
-        $this->assertEquals('test@example.com', $result->getAttribute('email'));
-        $this->assertEquals(false, $result->getAttribute('emailVerification'));
-        $this->assertEquals(1, $result->getAttribute('status'));
-        $this->assertEquals('randomhash', $result->getAttribute('password'));
-        $this->assertEquals('2000-06-12 14:12:55.000', $result->getAttribute('passwordUpdate'));
-        $this->assertEquals('1975-06-12 13:12:55.000', $result->getAttribute('registration'));
-        $this->assertEquals(false, $result->getAttribute('reset'));
-        $this->assertEquals('My Name', $result->getAttribute('name'));
-        $this->assertEquals('{}', $result->getAttribute('prefs'));
-        $this->assertEquals('[]', $result->getAttribute('sessions'));
-        $this->assertEquals('[]', $result->getAttribute('tokens'));
-        $this->assertEquals('[]', $result->getAttribute('memberships'));
-        $this->assertEquals(['admin', 'developer', 'tester',], $result->getAttribute('roles'));
-        $this->assertEquals(['{"$id":"1","label":"x"}', '{"$id":"2","label":"y"}', '{"$id":"3","label":"z"}',], $result->getAttribute('tags'));
+    public function testUpsertDuplicateIds(): void
+    {
+        $db = $this->getDatabase();
+        if (!($db->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $result = $database->decode($collection, $document);
+        $db->createCollection(new Collection(id: __FUNCTION__));
+        $db->createAttribute(__FUNCTION__, Attribute::integer(key: 'num', required: true));
 
-        $this->assertEquals('608fdbe51361a', $result->getAttribute('$id'));
-        $this->assertContains('read("any")', $result->getAttribute('$permissions'));
-        $this->assertContains('read("any")', $result->getPermissions());
-        $this->assertContains('any', $result->getRead());
-        $this->assertContains(Permission::create(Role::user('608fdbe51361a')), $result->getPermissions());
-        $this->assertContains('user:608fdbe51361a', $result->getCreate());
-        $this->assertContains('user:608fdbe51361a', $result->getWrite());
-        $this->assertEquals('test@example.com', $result->getAttribute('email'));
-        $this->assertEquals(false, $result->getAttribute('emailVerification'));
-        $this->assertEquals(1, $result->getAttribute('status'));
-        $this->assertEquals('randomhash', $result->getAttribute('password'));
-        $this->assertEquals('2000-06-12T14:12:55.000+00:00', $result->getAttribute('passwordUpdate'));
-        $this->assertEquals('1975-06-12T13:12:55.000+00:00', $result->getAttribute('registration'));
-        $this->assertEquals(false, $result->getAttribute('reset'));
-        $this->assertEquals('My Name', $result->getAttribute('name'));
-        $this->assertEquals([], $result->getAttribute('prefs'));
-        $this->assertEquals([], $result->getAttribute('sessions'));
-        $this->assertEquals([], $result->getAttribute('tokens'));
-        $this->assertEquals([], $result->getAttribute('memberships'));
-        $this->assertEquals(['admin', 'developer', 'tester',], $result->getAttribute('roles'));
-        $this->assertEquals([
-            new Document(['$id' => '1', 'label' => 'x']),
-            new Document(['$id' => '2', 'label' => 'y']),
-            new Document(['$id' => '3', 'label' => 'z']),
-        ], $result->getAttribute('tags'));
+        $doc1 = new Document(['$id' => 'dup', 'num' => 1]);
+        $doc2 = new Document(['$id' => 'dup', 'num' => 2]);
+
+        try {
+            $db->upsertDocuments(__FUNCTION__, [$doc1, $doc2]);
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e, $e->getMessage());
+        }
     }
-    /**
-     * @depends testGetDocument
-     */
-    public function testUpdateDocument(Document $document): Document
+
+    public function testPreserveSequenceUpsert(): void
     {
-        $document
-            ->setAttribute('string', 'text📝 updated')
-            ->setAttribute('integer_signed', -6)
-            ->setAttribute('integer_unsigned', 6)
-            ->setAttribute('float_signed', -5.56)
-            ->setAttribute('float_unsigned', 5.56)
-            ->setAttribute('boolean', false)
-            ->setAttribute('colors', 'red', Document::SET_TYPE_APPEND)
-            ->setAttribute('with-dash', 'Works');
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
+        if (!($database->getAdapter()->hasFeature(Feature\Upserts::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $this->assertNotEmpty($new->getId());
-        $this->assertIsString($new->getAttribute('string'));
-        $this->assertEquals('text📝 updated', $new->getAttribute('string'));
-        $this->assertIsInt($new->getAttribute('integer_signed'));
-        $this->assertEquals(-6, $new->getAttribute('integer_signed'));
-        $this->assertIsInt($new->getAttribute('integer_unsigned'));
-        $this->assertEquals(6, $new->getAttribute('integer_unsigned'));
-        $this->assertIsFloat($new->getAttribute('float_signed'));
-        $this->assertEquals(-5.56, $new->getAttribute('float_signed'));
-        $this->assertIsFloat($new->getAttribute('float_unsigned'));
-        $this->assertEquals(5.56, $new->getAttribute('float_unsigned'));
-        $this->assertIsBool($new->getAttribute('boolean'));
-        $this->assertEquals(false, $new->getAttribute('boolean'));
-        $this->assertIsArray($new->getAttribute('colors'));
-        $this->assertEquals(['pink', 'green', 'blue', 'red'], $new->getAttribute('colors'));
-        $this->assertEquals('Works', $new->getAttribute('with-dash'));
+        $collectionName = 'preserve_sequence_upsert';
 
-        $oldPermissions = $document->getPermissions();
+        $database->createCollection(new Collection(id: $collectionName));
 
-        $new
-            ->setAttribute('$permissions', Permission::read(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::create(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::update(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::delete(Role::guests()), Document::SET_TYPE_APPEND);
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $database->createAttribute($collectionName, Attribute::string(key: 'name', size: 128, required: true));
+        }
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        // Create initial documents
+        $doc1 = $database->createDocument($collectionName, new Document([
+            '$id' => 'doc1',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+            ],
+            'name' => 'Alice',
+        ]));
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        $doc2 = $database->createDocument($collectionName, new Document([
+            '$id' => 'doc2',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+            ],
+            'name' => 'Bob',
+        ]));
 
-        $this->assertContains('guests', $new->getRead());
-        $this->assertContains('guests', $new->getWrite());
-        $this->assertContains('guests', $new->getCreate());
-        $this->assertContains('guests', $new->getUpdate());
-        $this->assertContains('guests', $new->getDelete());
+        $originalSeq1 = $doc1->getSequence();
+        $originalSeq2 = $doc2->getSequence();
 
-        $new->setAttribute('$permissions', $oldPermissions);
+        $this->assertNotEmpty($originalSeq1);
+        $this->assertNotEmpty($originalSeq2);
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        // Test: Without preserveSequence (default), $sequence should be ignored
+        $database->setPreserveSequence(false);
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        $database->upsertDocuments($collectionName, [
+            new Document([
+                '$id' => 'doc1',
+                '$sequence' => 999, // Try to set a different sequence
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                ],
+                'name' => 'Alice Updated',
+            ]),
+        ]);
 
-        $this->assertNotContains('guests', $new->getRead());
-        $this->assertNotContains('guests', $new->getWrite());
-        $this->assertNotContains('guests', $new->getCreate());
-        $this->assertNotContains('guests', $new->getUpdate());
-        $this->assertNotContains('guests', $new->getDelete());
+        $doc1Updated = $database->getDocument($collectionName, 'doc1');
+        $this->assertEquals('Alice Updated', $doc1Updated->getAttribute('name'));
+        $this->assertEquals($originalSeq1, $doc1Updated->getSequence()); // Sequence unchanged
 
-        // Test change document ID
-        $id = $new->getId();
-        $newId = 'new-id';
-        $new->setAttribute('$id', $newId);
-        $new = $this->getDatabase()->updateDocument($new->getCollection(), $id, $new);
-        $this->assertEquals($newId, $new->getId());
+        // Test: With preserveSequence=true, $sequence from document should be used
+        $database->setPreserveSequence(true);
 
-        // Reset ID
-        $new->setAttribute('$id', $id);
-        $new = $this->getDatabase()->updateDocument($new->getCollection(), $newId, $new);
-        $this->assertEquals($id, $new->getId());
+        $database->upsertDocuments($collectionName, [
+            new Document([
+                '$id' => 'doc2',
+                '$sequence' => $originalSeq2, // Keep original sequence
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                ],
+                'name' => 'Bob Updated',
+            ]),
+        ]);
 
-        return $document;
-    }
+        $doc2Updated = $database->getDocument($collectionName, 'doc2');
+        $this->assertEquals('Bob Updated', $doc2Updated->getAttribute('name'));
+        $this->assertEquals($originalSeq2, $doc2Updated->getSequence()); // Sequence preserved
 
+        // Test: withPreserveSequence helper
+        $database->setPreserveSequence(false);
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testUpdateDocumentConflict(Document $document): void
-    {
-        $document->setAttribute('integer_signed', 7);
-        $result = $this->getDatabase()->withRequestTimestamp(new \DateTime(), function () use ($document) {
-            return $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
+        $doc1 = $database->getDocument($collectionName, 'doc1');
+        $currentSeq1 = $doc1->getSequence();
+
+        $database->withPreserveSequence(function () use ($database, $collectionName, $currentSeq1) {
+            $database->upsertDocuments($collectionName, [
+                new Document([
+                    '$id' => 'doc1',
+                    '$sequence' => $currentSeq1,
+                    '$permissions' => [
+                        Permission::read(Role::any()),
+                        Permission::update(Role::any()),
+                    ],
+                    'name' => 'Alice Final',
+                ]),
+            ]);
         });
-        $this->assertEquals(7, $result->getAttribute('integer_signed'));
 
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
-        $document->setAttribute('integer_signed', 8);
+        $doc1Final = $database->getDocument($collectionName, 'doc1');
+        $this->assertEquals('Alice Final', $doc1Final->getAttribute('name'));
+        $this->assertEquals($currentSeq1, $doc1Final->getSequence());
+
+        // Verify flag was reset after withPreserveSequence
+        $this->assertFalse($database->getPreserveSequence());
+
+        // Test: With preserveSequence=true, invalid $sequence should throw error (SQL adapters only)
+        $database->setPreserveSequence(true);
+
         try {
-            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($document) {
-                return $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
-            });
-            $this->fail('Failed to throw exception');
+            $database->upsertDocuments($collectionName, [
+                new Document([
+                    '$id' => 'doc1',
+                    '$sequence' => 'abc', // Invalid sequence value
+                    '$permissions' => [
+                        Permission::read(Role::any()),
+                        Permission::update(Role::any()),
+                    ],
+                    'name' => 'Alice Invalid',
+                ]),
+            ]);
+            // Schemaless adapters may not validate sequence type, so only fail for schemaful
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+                $this->fail('Expected StructureException for invalid sequence');
+            }
         } catch (Throwable $e) {
-            $this->assertTrue($e instanceof ConflictException);
-            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+                $this->assertInstanceOf(StructureException::class, $e);
+                $this->assertStringContainsString('sequence', $e->getMessage());
+            }
         }
-    }
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testDeleteDocumentConflict(Document $document): void
-    {
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
-        $this->expectException(ConflictException::class);
-        $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($document) {
-            return $this->getDatabase()->deleteDocument($document->getCollection(), $document->getId());
-        });
+        $database->setPreserveSequence(false);
+        $database->deleteCollection($collectionName);
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testUpdateDocumentDuplicatePermissions(Document $document): Document
+    public function testRespectNulls(): void
     {
-        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
-
-        $new
-            ->setAttribute('$permissions', Permission::read(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::read(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::create(Role::guests()), Document::SET_TYPE_APPEND)
-            ->setAttribute('$permissions', Permission::create(Role::guests()), Document::SET_TYPE_APPEND);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        $database->createCollection(new Collection(id: 'documents_nulls'));
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', Attribute::string(key: 'string', size: 128)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', Attribute::integer(key: 'integer')));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', Attribute::integer(key: 'bigint', size: 8)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', Attribute::double(key: 'float')));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', Attribute::boolean(key: 'boolean')));
 
-        $this->assertContains('guests', $new->getRead());
-        $this->assertContains('guests', $new->getCreate());
+        $document = $database->createDocument('documents_nulls', new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::read(Role::user('1')),
+                Permission::read(Role::user('2')),
+                Permission::create(Role::any()),
+                Permission::create(Role::user('1x')),
+                Permission::create(Role::user('2x')),
+                Permission::update(Role::any()),
+                Permission::update(Role::user('1x')),
+                Permission::update(Role::user('2x')),
+                Permission::delete(Role::any()),
+                Permission::delete(Role::user('1x')),
+                Permission::delete(Role::user('2x')),
+            ],
+        ]));
 
-        return $document;
+        $this->assertNotEmpty($document->getId());
+        $this->assertNull($document->getAttribute('string'));
+        $this->assertNull($document->getAttribute('integer'));
+        $this->assertNull($document->getAttribute('bigint'));
+        $this->assertNull($document->getAttribute('float'));
+        $this->assertNull($document->getAttribute('boolean'));
     }
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testDeleteDocument(Document $document): void
+    public function testCreateDocumentDefaults(): void
     {
-        $result = $this->getDatabase()->deleteDocument($document->getCollection(), $document->getId());
-        $document = $this->getDatabase()->getDocument($document->getCollection(), $document->getId());
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals(true, $result);
-        $this->assertEquals(true, $document->isEmpty());
+        $database->createCollection(new Collection(id: 'defaults'));
+
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::string(key: 'string', size: 128, default: 'default')));
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::integer(key: 'integer', default: 1)));
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::double(key: 'float', default: 1.5)));
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::boolean(key: 'boolean', default: true)));
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::string(key: 'colors', size: 32, default: ['red', 'green', 'blue'], array: true)));
+        $this->assertEquals(true, $database->createAttribute('defaults', Attribute::datetime(key: 'datetime', default: '2000-06-12T14:12:55.000+00:00', filters: ['datetime'])));
+
+        $document = $database->createDocument('defaults', new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+        ]));
+
+        $document2 = $database->getDocument('defaults', $document->getId());
+        $this->assertCount(4, $document2->getPermissions());
+        $this->assertEquals('read("any")', $document2->getPermissions()[0]);
+        $this->assertEquals('create("any")', $document2->getPermissions()[1]);
+        $this->assertEquals('update("any")', $document2->getPermissions()[2]);
+        $this->assertEquals('delete("any")', $document2->getPermissions()[3]);
+
+        $this->assertNotEmpty($document->getId());
+        $this->assertIsString($document->getAttribute('string'));
+        $this->assertEquals('default', $document->getAttribute('string'));
+        $this->assertIsInt($document->getAttribute('integer'));
+        $this->assertEquals(1, $document->getAttribute('integer'));
+        $this->assertIsFloat($document->getAttribute('float'));
+        $this->assertEquals(1.5, $document->getAttribute('float'));
+        $this->assertIsArray($document->getAttribute('colors'));
+        $this->assertCount(3, $document->getAttribute('colors'));
+        $this->assertEquals('red', $document->getAttribute('colors')[0]);
+        $this->assertEquals('green', $document->getAttribute('colors')[1]);
+        $this->assertEquals('blue', $document->getAttribute('colors')[2]);
+        $this->assertEquals('2000-06-12T14:12:55.000+00:00', $document->getAttribute('datetime'));
+
+        // cleanup collection
+        $database->deleteCollection('defaults');
     }
 
-    public function testUpdateDocuments(): void
+    public function testIncreaseDecrease(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $collection = $this->getIncDecCollection();
+        $database->createCollection(new Collection(id: $collection));
 
-        $collection = 'testUpdateDocuments';
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'increase', required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'decrease', required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'increase_text', required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::double(key: 'increase_float', required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::integer(key: 'sizes', size: 8, array: true)));
 
-        $database->createCollection($collection, attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('integer'),
-                'type' => Database::VAR_INTEGER,
-                'format' => '',
-                'size' => 10000,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('boolean'),
-                'type' => Database::VAR_BOOLEAN,
-                'format' => '',
-                'size' => 0,
-                'signed' => true,
-                'required' => false,
-                'default' => false, // not null
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: false);
-
-        for ($i = 0; $i < 10; $i++) {
-            $database->createDocument($collection, new Document([
-                '$id' => 'doc' . $i,
-                'string' => 'text📝 ' . $i,
-                'integer' => $i,
-                'boolean' => true
-            ]));
-        }
+        $document = $database->createDocument($collection, new Document([
+            'increase' => 100,
+            'decrease' => 100,
+            'increase_float' => 100,
+            'increase_text' => 'some text',
+            'sizes' => [10, 20, 30],
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ]
+        ]));
 
-        // Test Update half of the documents
-        $results = [];
-        $count = $database->updateDocuments($collection, new Document([
-            'string' => 'text📝 updated',
-        ]), [
-            Query::greaterThanEqual('integer', 5),
-        ], onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-        });
+        $updatedAt = $document->getUpdatedAt();
 
-        $this->assertEquals(5, $count);
+        $doc = $database->increaseDocumentAttribute($collection, $document->getId(), 'increase', 1, 101);
+        $this->assertEquals(101, $doc->getAttribute('increase'));
 
-        foreach ($results as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-            $this->assertEquals(true, $document->getAttribute('boolean'));
-        }
+        $document = $database->getDocument($collection, $document->getId());
+        $this->assertEquals(101, $document->getAttribute('increase'));
+        $this->assertNotEquals($updatedAt, $document->getUpdatedAt());
 
-        $updatedDocuments = $database->find($collection, [
-            Query::greaterThanEqual('integer', 5),
-        ]);
+        $doc = $database->decreaseDocumentAttribute($collection, $document->getId(), 'decrease', 1, 98);
+        $this->assertEquals(99, $doc->getAttribute('decrease'));
+        $document = $database->getDocument($collection, $document->getId());
+        $this->assertEquals(99, $document->getAttribute('decrease'));
 
-        $this->assertCount(5, $updatedDocuments);
+        $doc = $database->increaseDocumentAttribute($collection, $document->getId(), 'increase_float', 5.5, 110);
+        $this->assertEquals(105.5, $doc->getAttribute('increase_float'));
+        $document = $database->getDocument($collection, $document->getId());
+        $this->assertEquals(105.5, $document->getAttribute('increase_float'));
 
-        foreach ($updatedDocuments as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
-            $this->assertEquals(true, $document->getAttribute('boolean'));
-        }
+        $doc = $database->decreaseDocumentAttribute($collection, $document->getId(), 'increase_float', 1.1, 100);
+        $this->assertEquals(104.4, $doc->getAttribute('increase_float'));
+        $document = $database->getDocument($collection, $document->getId());
+        $this->assertEquals(104.4, $document->getAttribute('increase_float'));
 
-        $controlDocuments = $database->find($collection, [
-            Query::lessThan('integer', 5),
-        ]);
+        self::$incDecFixtureInit = true;
+        self::$incDecFixtureDoc = $document;
+    }
 
-        $this->assertEquals(count($controlDocuments), 5);
+    public function testIncreaseLimitMax(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        foreach ($controlDocuments as $document) {
-            $this->assertNotEquals('text📝 updated', $document->getAttribute('string'));
-        }
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Test Update all documents
-        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
-            'string' => 'text📝 updated all',
-        ])));
+        $this->expectException(Exception::class);
+        $this->assertEquals(true, $database->increaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'increase', 10.5, 102.4));
+    }
+    public function testDecreaseLimitMin(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        $updatedDocuments = $database->find($collection);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals(count($updatedDocuments), 10);
+        try {
+            $database->decreaseDocumentAttribute(
+                $this->getIncDecCollection(),
+                $document->getId(),
+                'decrease',
+                10,
+                99
+            );
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(LimitException::class, $e);
+        }
 
-        foreach ($updatedDocuments as $document) {
-            $this->assertEquals('text📝 updated all', $document->getAttribute('string'));
+        try {
+            $database->decreaseDocumentAttribute(
+                $this->getIncDecCollection(),
+                $document->getId(),
+                'decrease',
+                1000,
+                0
+            );
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(LimitException::class, $e);
         }
+    }
+    public function testIncreaseTextAttribute(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        // TEST: Can't delete documents in the past
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         try {
-            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($collection, $database) {
-                $database->updateDocuments($collection, new Document([
-                    'string' => 'text📝 updated all',
-                ]));
-            });
-            $this->fail('Failed to throw exception');
-        } catch (ConflictException $e) {
-            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
+            $this->assertEquals(false, $database->increaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'increase_text'));
+            $this->fail('Expected TypeException not thrown');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(TypeException::class, $e, $e->getMessage());
         }
+    }
+    public function testIncreaseArrayAttribute(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        // Check collection level permissions
-        $database->updateCollection($collection, permissions: [
-            Permission::read(Role::user('asd')),
-            Permission::create(Role::user('asd')),
-            Permission::update(Role::user('asd')),
-            Permission::delete(Role::user('asd')),
-        ], documentSecurity: false);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         try {
-            $database->updateDocuments($collection, new Document([
-                'string' => 'text📝 updated all',
-            ]));
-            $this->fail('Failed to throw exception');
-        } catch (AuthorizationException $e) {
-            $this->assertStringStartsWith('Missing "update" permission for role "user:asd".', $e->getMessage());
+            $this->assertEquals(false, $database->increaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'sizes'));
+            $this->fail('Expected TypeException not thrown');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(TypeException::class, $e);
         }
+    }
+    public function testIncreaseDecreasePreserveDates(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        // Check document level permissions
-        $database->updateCollection($collection, permissions: [], documentSecurity: true);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
-            $database->updateDocument($collection, 'doc0', new Document([
-                'string' => 'text📝 updated all',
-                '$permissions' => [
-                    Permission::read(Role::user('asd')),
-                    Permission::create(Role::user('asd')),
-                    Permission::update(Role::user('asd')),
-                    Permission::delete(Role::user('asd')),
-                ],
-            ]));
-        });
+        $database->setPreserveDates(true);
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::user('asd')->toString());
+        try {
+            $before = $database->getDocument($this->getIncDecCollection(), $document->getId());
+            $updatedAt = $before->getUpdatedAt();
+            $increase = $before->getAttribute('increase');
+            $decrease = $before->getAttribute('decrease');
+            $this->assertIsNumeric($increase);
+            $this->assertIsNumeric($decrease);
 
-        $database->updateDocuments($collection, new Document([
-            'string' => 'permission text',
-        ]));
+            $database->increaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'increase', 1);
 
-        $documents = $database->find($collection, [
-            Query::equal('string', ['permission text']),
-        ]);
+            $after = $database->getDocument($this->getIncDecCollection(), $document->getId());
+            $this->assertSame($increase + 1, $after->getAttribute('increase'));
+            $this->assertSame($updatedAt, $after->getUpdatedAt());
 
-        $this->assertCount(1, $documents);
+            $database->decreaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'decrease', 1);
 
-        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
-            $unmodifiedDocuments = $database->find($collection, [
-                Query::equal('string', ['text📝 updated all']),
-            ]);
+            $after = $database->getDocument($this->getIncDecCollection(), $document->getId());
+            $this->assertSame($decrease - 1, $after->getAttribute('decrease'));
+            $this->assertSame($updatedAt, $after->getUpdatedAt());
+        } finally {
+            $database->setPreserveDates(false);
+        }
+    }
+    public function testGetDocumentSelect(): void
+    {
+        $document = $this->initDocumentsFixture(__FUNCTION__);
 
-            $this->assertCount(9, $unmodifiedDocuments);
-        });
+        $documentId = $document->getId();
 
-        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
-            $database->updateDocuments($collection, new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-            ]));
-        });
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Test we can update more documents than batchSize
-        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
-            'string' => 'batchSize Test'
-        ]), batchSize: 2));
+        $document = $database->getDocument($document->getCollection(), $documentId, [
+            Query::select(['string', 'integer_signed']),
+        ]);
 
-        $documents = $database->find($collection);
+        $this->assertFalse($document->isEmpty());
+        $this->assertIsString($document->getAttribute('string'));
+        $this->assertNotEmpty($document->getAttribute('string'));
+        $this->assertIsInt($document->getAttribute('integer_signed'));
+        $this->assertArrayNotHasKey('float', $document->getAttributes());
+        $this->assertArrayNotHasKey('boolean', $document->getAttributes());
+        $this->assertArrayNotHasKey('colors', $document->getAttributes());
+        $this->assertArrayNotHasKey('with-dash', $document->getAttributes());
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayHasKey('$sequence', $document);
+        $this->assertArrayHasKey('$createdAt', $document);
+        $this->assertArrayHasKey('$updatedAt', $document);
+        $this->assertArrayHasKey('$permissions', $document);
+        $this->assertArrayHasKey('$collection', $document);
 
-        foreach ($documents as $document) {
-            $this->assertEquals('batchSize Test', $document->getAttribute('string'));
-        }
+        $document = $database->getDocument($document->getCollection(), $documentId, [
+            Query::select(['string', 'integer_signed', '$id']),
+        ]);
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayHasKey('$sequence', $document);
+        $this->assertArrayHasKey('$createdAt', $document);
+        $this->assertArrayHasKey('$updatedAt', $document);
+        $this->assertArrayHasKey('$permissions', $document);
+        $this->assertArrayHasKey('$collection', $document);
+        $this->assertArrayHasKey('string', $document);
+        $this->assertArrayHasKey('integer_signed', $document);
+        $this->assertArrayNotHasKey('float', $document);
     }
 
-    public function testUpdateDocumentsWithCallbackSupport(): void
+    public function testDocumentsFixturesCanBeIsolated(): void
     {
-        /** @var Database $database */
+        $first = $this->initDocumentsFixture('fixtureIsolationFirst');
+        $second = $this->initDocumentsFixture('fixtureIsolationSecond');
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $database->deleteDocument($first->getCollection(), $first->getId());
 
-        $collection = 'update_callback';
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->assertSame(true, $database->getDocument($first->getCollection(), $first->getId())->isEmpty());
+        $document = $database->getDocument($second->getCollection(), $second->getId());
+        $this->assertSame(false, $document->isEmpty());
+        $this->assertSame(-Database::MAX_INT, $document->getAttribute('integer_signed'));
+    }
 
-        $database->createCollection($collection, attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('integer'),
-                'type' => Database::VAR_INTEGER,
-                'format' => '',
-                'size' => 10000,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: false);
+    public function testFindOne(): void
+    {
+        $this->initMoviesFixture();
 
-        for ($i = 0; $i < 10; $i++) {
-            $database->createDocument($collection, new Document([
-                '$id' => 'doc' . $i,
-                'string' => 'text📝 ' . $i,
-                'integer' => $i
-            ]));
-        }
-        // Test onNext is throwing the error without the onError
-        // a non existent document to test the error thrown
-        try {
-            $results = [];
-            $count = $database->updateDocuments($collection, new Document([
-                'string' => 'text📝 updated',
-            ]), [
-                Query::greaterThanEqual('integer', 100),
-            ], onNext: function ($doc) use (&$results) {
-                $results[] = $doc;
-                throw new Exception("Error thrown to test that update doesn't stop and error is caught");
-            });
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals("Error thrown to test that update doesn't stop and error is caught", $e->getMessage());
-        }
-
-        // Test Update half of the documents
-        $results = [];
-        $count = $database->updateDocuments($collection, new Document([
-            'string' => 'text📝 updated',
-        ]), [
-            Query::greaterThanEqual('integer', 5),
-        ], onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-            throw new Exception("Error thrown to test that update doesn't stop and error is caught");
-        }, onError:function ($e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals("Error thrown to test that update doesn't stop and error is caught", $e->getMessage());
-        });
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals(5, $count);
+        $document = $database->findOne($this->getMoviesCollection(), [
+            Query::offset(2),
+            Query::orderAsc('name')
+        ]);
 
-        foreach ($results as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-        }
+        $this->assertFalse($document->isEmpty());
+        $this->assertEquals('Frozen', $document->getAttribute('name'));
 
-        $updatedDocuments = $database->find($collection, [
-            Query::greaterThanEqual('integer', 5),
+        $document = $database->findOne($this->getMoviesCollection(), [
+            Query::offset(10)
         ]);
-
-        $this->assertCount(5, $updatedDocuments);
+        $this->assertTrue($document->isEmpty());
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testReadPermissionsSuccess(Document $document): Document
+    public function testFindBasicChecks(): void
     {
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->initMoviesFixture();
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument('documents', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'string' => 'text📝',
-            'integer_signed' => -Database::MAX_INT,
-            'integer_unsigned' => Database::MAX_INT,
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'bigint_unsigned' => Database::MAX_BIG_INT,
-            'float_signed' => -5.55,
-            'float_unsigned' => 5.55,
-            'boolean' => true,
-            'colors' => ['pink', 'green', 'blue'],
-        ]));
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
 
-        $this->assertEquals(false, $document->isEmpty());
+        try {
+            $documents = $database->find($this->getMoviesCollection());
+            $movieDocuments = $documents;
+
+            $this->assertEquals(5, count($documents));
+            $this->assertNotEmpty($documents[0]->getId());
+            $this->assertEquals($this->getMoviesCollection(), $documents[0]->getCollection());
+            $this->assertEquals(['any', 'user:1', 'user:2'], $documents[0]->getRead());
+            $this->assertEquals(['any', 'user:1x', 'user:2x'], $documents[0]->getWrite());
+            $this->assertEquals('Frozen', $documents[0]->getAttribute('name'));
+            $this->assertEquals('Chris Buck & Jennifer Lee', $documents[0]->getAttribute('director'));
+            $this->assertIsString($documents[0]->getAttribute('director'));
+            $this->assertEquals(2013, $documents[0]->getAttribute('year'));
+            $this->assertIsInt($documents[0]->getAttribute('year'));
+            $this->assertEquals(39.50, $documents[0]->getAttribute('price'));
+            $this->assertIsFloat($documents[0]->getAttribute('price'));
+            $this->assertEquals(true, $documents[0]->getAttribute('active'));
+            $this->assertIsBool($documents[0]->getAttribute('active'));
+            $this->assertEquals(['animation', 'kids'], $documents[0]->getAttribute('genres'));
+            $this->assertIsArray($documents[0]->getAttribute('genres'));
+            $this->assertEquals('Works', $documents[0]->getAttribute('with-dash'));
+
+            // Alphabetical order
+            $sortedDocuments = $movieDocuments;
+            \usort($sortedDocuments, function (Document $doc1, Document $doc2) {
+                return strcmp($doc1->getId(), $doc2->getId());
+            });
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
+            $firstDocumentId = $sortedDocuments[0]->getId();
+            $lastDocumentId = $sortedDocuments[\count($sortedDocuments) - 1]->getId();
 
-        $document = $database->getDocument($document->getCollection(), $document->getId());
-        $this->assertEquals(true, $document->isEmpty());
+            /**
+             * Check $id: Notice, this orders ID names alphabetically, not by internal numeric ID
+             */
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::limit(25),
+                Query::offset(0),
+                Query::orderDesc('$id'),
+            ]);
+            $this->assertEquals($lastDocumentId, $documents[0]->getId());
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::limit(25),
+                Query::offset(0),
+                Query::orderAsc('$id'),
+            ]);
+            $this->assertEquals($firstDocumentId, $documents[0]->getId());
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+            /**
+             * Check internal numeric ID sorting
+             */
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::limit(25),
+                Query::offset(0),
+                Query::orderDesc(''),
+            ]);
+            $this->assertEquals($movieDocuments[\count($movieDocuments) - 1]->getId(), $documents[0]->getId());
+            $documents = $database->find($this->getMoviesCollection(), [
+                Query::limit(25),
+                Query::offset(0),
+                Query::orderAsc(''),
+            ]);
+            $this->assertEquals($movieDocuments[0]->getId(), $documents[0]->getId());
 
-        return $document;
+        } finally {
+            $this->getDatabase()->getAuthorization()->addRole('user:x');
+        }
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testWritePermissionsSuccess(Document $document): void
+    public function testFindCheckPermissions(): void
     {
-        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->initMoviesFixture();
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->expectException(AuthorizationException::class);
-        $database->createDocument('documents', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'string' => 'text📝',
-            'integer_signed' => -Database::MAX_INT,
-            'integer_unsigned' => Database::MAX_INT,
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'bigint_unsigned' => Database::MAX_BIG_INT,
-            'float_signed' => -5.55,
-            'float_unsigned' => 5.55,
-            'boolean' => true,
-            'colors' => ['pink', 'green', 'blue'],
-        ]));
+        /**
+         * Check Permissions
+         */
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
+        $documents = $database->find($this->getMoviesCollection());
+
+        $this->assertEquals(6, count($documents));
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testWritePermissionsUpdateFailure(Document $document): Document
+    public function testFindStringQueryEqual(): void
     {
-        $this->expectException(AuthorizationException::class);
-
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->initMoviesFixture();
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument('documents', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'string' => 'text📝',
-            'integer_signed' => -Database::MAX_INT,
-            'integer_unsigned' => Database::MAX_INT,
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'bigint_unsigned' => Database::MAX_BIG_INT,
-            'float_signed' => -5.55,
-            'float_unsigned' => 5.55,
-            'boolean' => true,
-            'colors' => ['pink', 'green', 'blue'],
-        ]));
+        /**
+         * String condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD']),
+        ]);
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->assertEquals(2, count($documents));
 
-        $document = $database->updateDocument('documents', $document->getId(), new Document([
-            '$id' => ID::custom($document->getId()),
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'string' => 'text📝',
-            'integer_signed' => 6,
-            'bigint_signed' => -Database::MAX_BIG_INT,
-            'float_signed' => -Database::MAX_DOUBLE,
-            'float_unsigned' => Database::MAX_DOUBLE,
-            'boolean' => true,
-            'colors' => ['pink', 'green', 'blue'],
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['']),
+        ]);
 
-        return $document;
+        $this->assertEquals(0, count($documents));
     }
 
-    /**
-     * @depends testFind
-     */
-    public function testUniqueIndexDuplicate(): void
+    public function testFindNotEqual(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->assertEquals(true, $database->createIndex('movies', 'uniqueIndex', Database::INDEX_UNIQUE, ['name'], [128], [Database::ORDER_ASC]));
+        /**
+         * Not Equal query
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEqual('director', 'TBD'),
+        ]);
 
-        try {
-            $database->createDocument('movies', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::read(Role::user('1')),
-                    Permission::read(Role::user('2')),
-                    Permission::create(Role::any()),
-                    Permission::create(Role::user('1x')),
-                    Permission::create(Role::user('2x')),
-                    Permission::update(Role::any()),
-                    Permission::update(Role::user('1x')),
-                    Permission::update(Role::user('2x')),
-                    Permission::delete(Role::any()),
-                    Permission::delete(Role::user('1x')),
-                    Permission::delete(Role::user('2x')),
-                ],
-                'name' => 'Frozen',
-                'director' => 'Chris Buck & Jennifer Lee',
-                'year' => 2013,
-                'price' => 39.50,
-                'active' => true,
-                'genres' => ['animation', 'kids'],
-                'with-dash' => 'Works4'
-            ]));
+        $this->assertGreaterThan(0, count($documents));
 
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-            $this->assertInstanceOf(UniqueException::class, $e);
+        foreach ($documents as $document) {
+            $this->assertTrue($document['director'] !== 'TBD');
         }
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEqual('director', ''),
+        ]);
+
+        $total = $database->count($this->getMoviesCollection());
+
+        $this->assertEquals($total, count($documents));
     }
 
-    /**
-     * Test that duplicate exceptions differentiate between
-     * document ID duplicates and unique index violations.
-     */
-    public function testDuplicateExceptionMessages(): void
+    public function testFindBetween(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUniqueIndex()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('price', 25.94, 25.99),
+        ]);
+        $this->assertEquals(2, count($documents));
 
-        $database->createCollection('duplicateMessages');
-        $database->createAttribute('duplicateMessages', 'email', Database::VAR_STRING, 128, true);
-        $database->createIndex('duplicateMessages', 'emailUnique', Database::INDEX_UNIQUE, ['email'], [128]);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('price', 30, 35),
+        ]);
+        $this->assertEquals(0, count($documents));
 
-        // Create first document
-        $database->createDocument('duplicateMessages', new Document([
-            '$id' => 'dup_msg_1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'email' => 'test@example.com',
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('$createdAt', '1975-12-06', '2050-12-06'),
+        ]);
+        $this->assertEquals(6, count($documents));
 
-        // Test 1: Duplicate document ID should say "Document already exists"
-        try {
-            $database->createDocument('duplicateMessages', new Document([
-                '$id' => 'dup_msg_1',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                ],
-                'email' => 'different@example.com',
-            ]));
-            $this->fail('Expected DuplicateException for duplicate document ID');
-        } catch (DuplicateException $e) {
-            $this->assertNotInstanceOf(UniqueException::class, $e);
-            $this->assertStringContainsString('Document already exists', $e->getMessage());
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('$updatedAt', '1975-12-06T07:08:49.733+02:00', '2050-02-05T10:15:21.825+00:00'),
+        ]);
+        $this->assertEquals(6, count($documents));
+    }
 
-        // Test 2: Unique index violation should use UniqueException
-        try {
-            $database->createDocument('duplicateMessages', new Document([
-                '$id' => 'dup_msg_2',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                ],
-                'email' => 'test@example.com',
-            ]));
-            $this->fail('Expected DuplicateException for unique index violation');
-        } catch (DuplicateException $e) {
-            $this->assertInstanceOf(UniqueException::class, $e);
-            $this->assertStringContainsString('Unique index violation', $e->getMessage());
-        }
+    public function testFindMultipleConditions(): void
+    {
+        $this->initMoviesFixture();
 
-        // Test 3: A conflicting value containing "_uid" must not be mistaken
-        // for a document identifier conflict
-        $database->createDocument('duplicateMessages', new Document([
-            '$id' => 'dup_msg_3',
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'email' => 'prefix_uid_suffix@example.com',
-        ]));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        try {
-            $database->createDocument('duplicateMessages', new Document([
-                '$id' => 'dup_msg_4',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                ],
-                'email' => 'prefix_uid_suffix@example.com',
-            ]));
-            $this->fail('Expected DuplicateException for unique index violation');
-        } catch (DuplicateException $e) {
-            $this->assertInstanceOf(UniqueException::class, $e);
-            $this->assertStringContainsString('Unique index violation', $e->getMessage());
-        }
+        /**
+         * Multiple conditions
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD']),
+            Query::equal('year', [2026]),
+        ]);
 
-        $database->deleteCollection('duplicateMessages');
+        $this->assertEquals(1, count($documents));
+
+        /**
+         * Multiple conditions and OR values
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('name', ['Frozen II', 'Captain Marvel']),
+        ]);
+
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals('Frozen II', $documents[0]['name']);
+        $this->assertEquals('Captain Marvel', $documents[1]['name']);
     }
 
-    /**
-     * @depends testUniqueIndexDuplicate
-     */
-    public function testUniqueIndexDuplicateUpdate(): void
+    public function testFindOrderBy(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
-        // create document then update to conflict with index
-        $document = $database->createDocument('movies', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::read(Role::user('1')),
-                Permission::read(Role::user('2')),
-                Permission::create(Role::any()),
-                Permission::create(Role::user('1x')),
-                Permission::create(Role::user('2x')),
-                Permission::update(Role::any()),
-                Permission::update(Role::user('1x')),
-                Permission::update(Role::user('2x')),
-                Permission::delete(Role::any()),
-                Permission::delete(Role::user('1x')),
-                Permission::delete(Role::user('2x')),
-            ],
-            'name' => 'Frozen 5',
-            'director' => 'Chris Buck & Jennifer Lee',
-            'year' => 2013,
-            'price' => 39.50,
-            'active' => true,
-            'genres' => ['animation', 'kids'],
-            'with-dash' => 'Works4'
-        ]));
-
-        try {
-            $database->updateDocument('movies', $document->getId(), $document->setAttribute('name', 'Frozen'));
+        /**
+         * ORDER BY
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('name')
+        ]);
 
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-            $this->assertInstanceOf(UniqueException::class, $e);
-        }
+        $this->assertEquals(6, count($documents));
+        $this->assertEquals('Frozen', $documents[0]['name']);
+        $this->assertEquals('Frozen II', $documents[1]['name']);
+        $this->assertEquals('Captain Marvel', $documents[2]['name']);
+        $this->assertEquals('Captain America: The First Avenger', $documents[3]['name']);
+        $this->assertEquals('Work in Progress', $documents[4]['name']);
+        $this->assertEquals('Work in Progress 2', $documents[5]['name']);
     }
 
-    public function propagateBulkDocuments(string $collection, int $amount = 10, bool $documentSecurity = false): void
+    public function testFindOrderByNatural(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        for ($i = 0; $i < $amount; $i++) {
-            $database->createDocument($collection, new Document(
-                array_merge([
-                    '$id' => 'doc' . $i,
-                    'text' => 'value' . $i,
-                    'integer' => $i
-                ], $documentSecurity ? [
-                    '$permissions' => [
-                        Permission::create(Role::any()),
-                        Permission::read(Role::any()),
-                    ],
-                ] : [])
-            ));
-        }
+        /**
+         * ORDER BY natural
+         */
+        $base = array_reverse($database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc(''),
+        ]);
+
+        $this->assertEquals(6, count($documents));
+        $this->assertEquals($base[0]['name'], $documents[0]['name']);
+        $this->assertEquals($base[1]['name'], $documents[1]['name']);
+        $this->assertEquals($base[2]['name'], $documents[2]['name']);
+        $this->assertEquals($base[3]['name'], $documents[3]['name']);
+        $this->assertEquals($base[4]['name'], $documents[4]['name']);
+        $this->assertEquals($base[5]['name'], $documents[5]['name']);
     }
 
-    public function testDeleteBulkDocuments(): void
+    public function testFindOrderByMultipleAttributes(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        /**
+         * ORDER BY - Multiple attributes
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderDesc('name')
+        ]);
 
-        $database->createCollection(
-            'bulk_delete',
-            attributes: [
-                new Document([
-                    '$id' => 'text',
-                    'type' => Database::VAR_STRING,
-                    'size' => 100,
-                    'required' => true,
-                ]),
-                new Document([
-                    '$id' => 'integer',
-                    'type' => Database::VAR_INTEGER,
-                    'size' => 10,
-                    'required' => true,
-                ])
-            ],
-            permissions: [
-                Permission::create(Role::any()),
-                Permission::read(Role::any()),
-                Permission::delete(Role::any())
-            ],
-            documentSecurity: false
-        );
+        $this->assertEquals(6, count($documents));
+        $this->assertEquals('Frozen II', $documents[0]['name']);
+        $this->assertEquals('Frozen', $documents[1]['name']);
+        $this->assertEquals('Captain Marvel', $documents[2]['name']);
+        $this->assertEquals('Captain America: The First Avenger', $documents[3]['name']);
+        $this->assertEquals('Work in Progress 2', $documents[4]['name']);
+        $this->assertEquals('Work in Progress', $documents[5]['name']);
+    }
 
-        $this->propagateBulkDocuments('bulk_delete');
+    public function testFindOrderByCursorAfter(): void
+    {
+        $this->initMoviesFixture();
 
-        $docs = $database->find('bulk_delete');
-        $this->assertCount(10, $docs);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         /**
-         * Test Short select query, test pagination as well, Add order to select
+         * ORDER BY - After
          */
-        $selects = ['$sequence', '$id', '$collection', '$permissions', '$updatedAt'];
-
-        $count = $database->deleteDocuments(
-            collection: 'bulk_delete',
-            queries: [
-                Query::select([...$selects, '$createdAt']),
-                Query::cursorAfter($docs[6]),
-                Query::greaterThan('$createdAt', '2000-01-01'),
-                Query::orderAsc('$createdAt'),
-                Query::orderAsc(),
-                Query::limit(2),
-            ],
-            batchSize: 1
-        );
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]);
 
-        $this->assertEquals(2, $count);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorAfter($movies[1])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
 
-        // TEST: Bulk Delete All Documents
-        $this->assertEquals(8, $database->deleteDocuments('bulk_delete'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorAfter($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
 
-        $docs = $database->find('bulk_delete');
-        $this->assertCount(0, $docs);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorAfter($movies[4])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
 
-        // TEST: Bulk delete documents with queries.
-        $this->propagateBulkDocuments('bulk_delete');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
 
-        $results = [];
-        $count = $database->deleteDocuments('bulk_delete', [
-            Query::greaterThanEqual('integer', 5)
-        ], onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-        });
+        /**
+         * Multiple order by, Test tie-break on year 2019
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::orderAsc('year'),
+            Query::orderAsc('price'),
+        ]);
 
-        $this->assertEquals(5, $count);
+        $this->assertEquals(6, count($movies));
 
-        foreach ($results as $document) {
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
-        }
+        $this->assertEquals($movies[0]['name'], 'Captain America: The First Avenger');
+        $this->assertEquals($movies[0]['year'], 2011);
+        $this->assertEquals($movies[0]['price'], 25.94);
 
-        $docs = $database->find('bulk_delete');
-        $this->assertEquals(5, \count($docs));
+        $this->assertEquals($movies[1]['name'], 'Frozen');
+        $this->assertEquals($movies[1]['year'], 2013);
+        $this->assertEquals($movies[1]['price'], 39.5);
 
-        // TEST (FAIL): Can't delete documents in the past
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        $this->assertEquals($movies[2]['name'], 'Captain Marvel');
+        $this->assertEquals($movies[2]['year'], 2019);
+        $this->assertEquals($movies[2]['price'], 25.99);
 
-        try {
-            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () {
-                return $this->getDatabase()->deleteDocuments('bulk_delete');
-            });
-            $this->fail('Failed to throw exception');
-        } catch (ConflictException $e) {
-            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
-        }
+        $this->assertEquals($movies[3]['name'], 'Frozen II');
+        $this->assertEquals($movies[3]['year'], 2019);
+        $this->assertEquals($movies[3]['price'], 39.5);
 
-        // TEST (FAIL): Bulk delete all documents with invalid collection permission
-        $database->updateCollection('bulk_delete', [], false);
-        try {
-            $database->deleteDocuments('bulk_delete');
-            $this->fail('Bulk deleted documents with invalid collection permission');
-        } catch (\Utopia\Database\Exception\Authorization) {
-        }
+        $this->assertEquals($movies[4]['name'], 'Work in Progress');
+        $this->assertEquals($movies[4]['year'], 2025);
+        $this->assertEquals($movies[4]['price'], 0);
 
-        $database->updateCollection('bulk_delete', [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::delete(Role::any())
-        ], false);
+        $this->assertEquals($movies[5]['name'], 'Work in Progress 2');
+        $this->assertEquals($movies[5]['year'], 2026);
+        $this->assertEquals($movies[5]['price'], 0);
 
-        $this->assertEquals(5, $database->deleteDocuments('bulk_delete'));
-        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+        $pos = 2;
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderAsc('year'),
+            Query::orderAsc('price'),
+            Query::cursorAfter($movies[$pos])
+        ]);
 
-        // TEST: Make sure we can't delete documents we don't have permissions for
-        $database->updateCollection('bulk_delete', [
-            Permission::create(Role::any()),
-        ], true);
-        $this->propagateBulkDocuments('bulk_delete', documentSecurity: true);
+        $this->assertEquals(3, count($documents));
 
-        $this->assertEquals(0, $database->deleteDocuments('bulk_delete'));
+        foreach ($documents as $i => $document) {
+            $this->assertEquals($document['name'], $movies[$i + 1 + $pos]['name']);
+            $this->assertEquals($document['price'], $movies[$i + 1 + $pos]['price']);
+            $this->assertEquals($document['year'], $movies[$i + 1 + $pos]['year']);
+        }
+    }
 
-        $documents = $this->getDatabase()->getAuthorization()->skip(function () use ($database) {
-            return $database->find('bulk_delete');
-        });
+    public function testFindOrderByCursorBefore(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals(10, \count($documents));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $database->updateCollection('bulk_delete', [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::delete(Role::any())
-        ], false);
+        /**
+         * ORDER BY - Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]);
 
-        $database->deleteDocuments('bulk_delete');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorBefore($movies[5])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
 
-        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorBefore($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
 
-        // Teardown
-        $database->deleteCollection('bulk_delete');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorBefore($movies[2])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorBefore($movies[1])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    public function testDeleteBulkDocumentsQueries(): void
+    public function testFindOrderByAfterNaturalOrder(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        /**
+         * ORDER BY - After by natural order
+         */
+        $movies = array_reverse($database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]));
 
-        $database->createCollection(
-            'bulk_delete_queries',
-            attributes: [
-                new Document([
-                    '$id' => 'text',
-                    'type' => Database::VAR_STRING,
-                    'size' => 100,
-                    'required' => true,
-                ]),
-                new Document([
-                    '$id' => 'integer',
-                    'type' => Database::VAR_INTEGER,
-                    'size' => 10,
-                    'required' => true,
-                ])
-            ],
-            documentSecurity: false,
-            permissions: [
-                Permission::create(Role::any()),
-                Permission::read(Role::any()),
-                Permission::delete(Role::any())
-            ]
-        );
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorAfter($movies[1])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
 
-        // Test limit
-        $this->propagateBulkDocuments('bulk_delete_queries');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorAfter($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
 
-        $this->assertEquals(5, $database->deleteDocuments('bulk_delete_queries', [Query::limit(5)]));
-        $this->assertEquals(5, \count($database->find('bulk_delete_queries')));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorAfter($movies[4])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
 
-        $this->assertEquals(5, $database->deleteDocuments('bulk_delete_queries', [Query::limit(5)]));
-        $this->assertEquals(0, \count($database->find('bulk_delete_queries')));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
+    }
 
-        // Test Limit more than batchSize
-        $this->propagateBulkDocuments('bulk_delete_queries', Database::DELETE_BATCH_SIZE * 2);
-        $this->assertEquals(Database::DELETE_BATCH_SIZE * 2, \count($database->find('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE * 2)])));
-        $this->assertEquals(Database::DELETE_BATCH_SIZE + 2, $database->deleteDocuments('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE + 2)]));
-        $this->assertEquals(Database::DELETE_BATCH_SIZE - 2, \count($database->find('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE * 2)])));
-        $this->assertEquals(Database::DELETE_BATCH_SIZE - 2, $this->getDatabase()->deleteDocuments('bulk_delete_queries'));
+    public function testFindOrderByBeforeNaturalOrder(): void
+    {
+        $this->initMoviesFixture();
 
-        // Test Offset
-        $this->propagateBulkDocuments('bulk_delete_queries', 100);
-        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries', [Query::offset(50)]));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $docs = $database->find('bulk_delete_queries', [Query::limit(100)]);
-        $this->assertEquals(50, \count($docs));
+        /**
+         * ORDER BY - Before by natural order
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc(''),
+        ]);
 
-        $lastDoc = \end($docs);
-        $this->assertNotEmpty($lastDoc);
-        $this->assertEquals('doc49', $lastDoc->getId());
-        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[5])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
 
-        $database->deleteCollection('bulk_delete_queries');
-    }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
 
-    public function testDeleteBulkDocumentsWithCallbackSupport(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[2])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[1])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
 
-        $database->createCollection(
-            'bulk_delete_with_callback',
-            attributes: [
-                new Document([
-                    '$id' => 'text',
-                    'type' => Database::VAR_STRING,
-                    'size' => 100,
-                    'required' => true,
-                ]),
-                new Document([
-                    '$id' => 'integer',
-                    'type' => Database::VAR_INTEGER,
-                    'size' => 10,
-                    'required' => true,
-                ])
-            ],
-            permissions: [
-                Permission::create(Role::any()),
-                Permission::read(Role::any()),
-                Permission::delete(Role::any())
-            ],
-            documentSecurity: false
-        );
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
+    }
 
-        $this->propagateBulkDocuments('bulk_delete_with_callback');
+    public function testFindOrderBySingleAttributeAfter(): void
+    {
+        $this->initMoviesFixture();
 
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertCount(10, $docs);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         /**
-         * Test Short select query, test pagination as well, Add order to select
+         * ORDER BY - Single Attribute After
          */
-        $selects = ['$sequence', '$id', '$collection', '$permissions', '$updatedAt'];
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('year')
+        ]);
 
-        try {
-            // a non existent document to test the error thrown
-            $database->deleteDocuments(
-                collection: 'bulk_delete_with_callback',
-                queries: [
-                    Query::select([...$selects, '$createdAt']),
-                    Query::lessThan('$createdAt', '1800-01-01'),
-                    Query::orderAsc('$createdAt'),
-                    Query::orderAsc(),
-                    Query::limit(1),
-                ],
-                batchSize: 1,
-                onNext: function () {
-                    throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
-                }
-            );
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
-        }
-
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertCount(10, $docs);
-
-        $count = $database->deleteDocuments(
-            collection: 'bulk_delete_with_callback',
-            queries: [
-                Query::select([...$selects, '$createdAt']),
-                Query::cursorAfter($docs[6]),
-                Query::greaterThan('$createdAt', '2000-01-01'),
-                Query::orderAsc('$createdAt'),
-                Query::orderAsc(),
-                Query::limit(2),
-            ],
-            batchSize: 1,
-            onNext: function () {
-                // simulating error throwing but should not stop deletion
-                throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
-            },
-            onError:function ($e) {
-                $this->assertInstanceOf(Exception::class, $e);
-                $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
-            }
-        );
-
-        $this->assertEquals(2, $count);
-
-        // TEST: Bulk Delete All Documents without passing callbacks
-        $this->assertEquals(8, $database->deleteDocuments('bulk_delete_with_callback'));
-
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertCount(0, $docs);
-
-        // TEST: Bulk delete documents with queries with callbacks
-        $this->propagateBulkDocuments('bulk_delete_with_callback');
-
-        $results = [];
-        $count = $database->deleteDocuments('bulk_delete_with_callback', [
-            Query::greaterThanEqual('integer', 5)
-        ], onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-            throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
-        }, onError:function ($e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
-        });
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[1])
+        ]);
 
-        $this->assertEquals(5, $count);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
 
-        foreach ($results as $document) {
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
 
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertEquals(5, \count($docs));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[4])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
 
-        // Teardown
-        $database->deleteCollection('bulk_delete_with_callback');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    public function testUpdateDocumentsQueries(): void
+    public function testFindOrderBySingleAttributeBefore(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'testUpdateDocumentsQueries';
-
-        $database->createCollection($collection, attributes: [
-            new Document([
-                '$id' => ID::custom('text'),
-                'type' => Database::VAR_STRING,
-                'size' => 64,
-                'required' => true,
-            ]),
-            new Document([
-                '$id' => ID::custom('integer'),
-                'type' => Database::VAR_INTEGER,
-                'size' => 64,
-                'required' => true,
-            ]),
-        ], permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: true);
-
-        // Test limit
-        $this->propagateBulkDocuments($collection, 100);
-
-        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
-            'text' => 'text📝 updated',
-        ]), [Query::limit(10)]));
+        /**
+         * ORDER BY - Single Attribute Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('year')
+        ]);
 
-        $this->assertEquals(10, \count($database->find($collection, [Query::equal('text', ['text📝 updated'])])));
-        $this->assertEquals(100, $database->deleteDocuments($collection));
-        $this->assertEquals(0, \count($database->find($collection)));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[5])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
 
-        // Test Offset
-        $this->propagateBulkDocuments($collection, 100);
-        $this->assertEquals(50, $database->updateDocuments($collection, new Document([
-            'text' => 'text📝 updated',
-        ]), [
-            Query::offset(50),
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[1]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[2]['name'], $documents[1]['name']);
 
-        $docs = $database->find($collection, [Query::equal('text', ['text📝 updated']), Query::limit(100)]);
-        $this->assertCount(50, $docs);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[2])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
 
-        $lastDoc = end($docs);
-        $this->assertNotEmpty($lastDoc);
-        $this->assertEquals('doc99', $lastDoc->getId());
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[1])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
 
-        $this->assertEquals(100, $database->deleteDocuments($collection));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testFulltextIndexWithInteger(): void
+    public function testFindOrderByMultipleAttributeAfter(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->expectException(Exception::class);
-            if (!$this->getDatabase()->getAdapter()->getSupportForFulltextIndex()) {
-                $this->expectExceptionMessage('Fulltext index is not supported');
-            } else {
-                $this->expectExceptionMessage('Attribute "integer_signed" cannot be part of a fulltext index, must be of type string');
-            }
+        /**
+         * ORDER BY - Multiple Attribute After
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year')
+        ]);
 
-            $database->createIndex('documents', 'fulltext_integer', Database::INDEX_FULLTEXT, ['string','integer_signed']);
-        } else {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorAfter($movies[1])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorAfter($movies[3])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[4]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[5]['name'], $documents[1]['name']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorAfter($movies[4])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[5]['name'], $documents[0]['name']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    public function testEnableDisableValidation(): void
+    public function testFindOrderByMultipleAttributeBefore(): void
     {
+        $this->initMoviesFixture();
+
+        /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('validation', permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
+        /**
+         * ORDER BY - Multiple Attribute Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year')
         ]);
 
-        $database->createAttribute(
-            'validation',
-            'name',
-            Database::VAR_STRING,
-            10,
-            false
-        );
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[5])
+        ]);
 
-        $database->createDocument('validation', new Document([
-            '$id' => 'docwithmorethan36charsasitsidentifier',
-            'name' => 'value1',
-        ]));
-
-        try {
-            $database->find('validation', queries: [
-                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-        }
-
-        $database->disableValidation();
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
 
-        $database->find('validation', queries: [
-            Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[4])
         ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
 
-        $database->enableValidation();
-
-        try {
-            $database->find('validation', queries: [
-                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[2])
+        ]);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[1]['name'], $documents[1]['name']);
 
-        $database->skipValidation(function () use ($database) {
-            $database->find('validation', queries: [
-                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
-            ]);
-        });
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[1])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
 
-        $database->enableValidation();
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testExceptionDuplicate(Document $document): void
+    public function testFindOrderByAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document->setAttribute('$id', 'duplicated');
-        $document->removeAttribute('$sequence');
-
-        $database->createDocument($document->getCollection(), $document);
-        $document->removeAttribute('$sequence');
+        /**
+         * ORDER BY + CURSOR
+         */
+        $documentsTest = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('price'),
+        ]);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(1),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::cursorAfter($documentsTest[0])
+        ]);
 
-        try {
-            $database->createDocument($document->getCollection(), $document);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testExceptionCaseInsensitiveDuplicate(Document $document): Document
+    public function testFindOrderByIdAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document->setAttribute('$id', 'caseSensitive');
-        $document->removeAttribute('$sequence');
-
-        $database->createDocument($document->getCollection(), $document);
-
-        $document->setAttribute('$id', 'CaseSensitive');
-        $document->removeAttribute('$sequence');
-
-        try {
-            $database->createDocument($document->getCollection(), $document);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        /**
+         * ORDER BY ID + CURSOR
+         */
+        $documentsTest = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('$id'),
+        ]);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(1),
+            Query::offset(0),
+            Query::orderDesc('$id'),
+            Query::cursorAfter($documentsTest[0])
+        ]);
 
-        return $document;
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
     }
 
-    public function testEmptyTenant(): void
+    public function testFindOrderByCreateDateAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSharedTables()) {
-            $documents = $database->find(
-                'documents',
-                [Query::select(['*'])] // Mongo bug with Integer UID
-            );
-
-            $document = $documents[0];
-            $doc = $database->getDocument($document->getCollection(), $document->getId());
-            $this->assertEquals($document->getTenant(), $doc->getTenant());
-            return;
-        }
-
-        $documents = $database->find(
-            'documents',
-            [Query::notEqual('$id', '56000')] // Mongo bug with Integer UID
-        );
-
-        $document = $documents[0];
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        /**
+         * ORDER BY CREATE DATE + CURSOR
+         */
+        $documentsTest = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('$createdAt'),
+        ]);
 
-        $document = $database->getDocument('documents', $document->getId());
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(1),
+            Query::offset(0),
+            Query::orderDesc('$createdAt'),
+            Query::cursorAfter($documentsTest[0])
+        ]);
 
-        $document = $database->updateDocument('documents', $document->getId(), $document);
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
     }
 
-    public function testEmptyOperatorValues(): void
+    public function testFindOrderByUpdateDateAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        try {
-            $database->findOne('documents', [
-                Query::equal('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Equal queries require at least one value.', $e->getMessage());
-        }
-
-        try {
-            $database->findOne('documents', [
-                Query::contains('string', []),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-            $this->assertEquals('Invalid query: Contains queries require at least one value.', $e->getMessage());
-        }
-    }
-
-    public function testDateTimeDocument(): void
-    {
         /**
-         * @var Database $database
+         * ORDER BY UPDATE DATE + CURSOR
          */
-        $database = $this->getDatabase();
-        $collection = 'create_modify_dates';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
-        $this->assertEquals(true, $database->createAttribute($collection, 'datetime', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']));
-
-        $date = '2000-01-01T10:00:00.000+00:00';
-        // test - default behaviour of external datetime attribute not changed
-        $doc = $database->createDocument($collection, new Document([
-            '$id' => 'doc1',
-            '$permissions' => [Permission::read(Role::any()),Permission::write(Role::any()),Permission::update(Role::any())],
-            'datetime' => ''
-        ]));
-        $this->assertNotEmpty($doc->getAttribute('datetime'));
-        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-
-        $doc = $database->getDocument($collection, 'doc1');
-        $this->assertNotEmpty($doc->getAttribute('datetime'));
-        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-
-        $database->setPreserveDates(true);
-        // test - modifying $createdAt and $updatedAt
-        $doc = $database->createDocument($collection, new Document([
-            '$id' => 'doc2',
-            '$permissions' => [Permission::read(Role::any()),Permission::write(Role::any()),Permission::update(Role::any())],
-            '$createdAt' => $date
-        ]));
-
-        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
-
-        $doc = $database->getDocument($collection, 'doc2');
-
-        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
+        $documentsTest = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('$updatedAt'),
+        ]);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(1),
+            Query::offset(0),
+            Query::orderDesc('$updatedAt'),
+            Query::cursorAfter($documentsTest[0])
+        ]);
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
     }
 
-    public function testDateTimeArrayDocument(): void
+    public function testFindCreatedBefore(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = 'datetime_array_doc';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'dates', Database::VAR_DATETIME, 0, false, null, false, true, null, [], ['datetime']));
-
-        $d1 = '2000-01-01T10:00:00.000+00:00';
-        $d2 = '2001-02-03T05:06:07.000+00:00';
+        /**
+         * Test Query::createdBefore wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        $database->createDocument($collection, new Document([
-            '$id' => 'doc1',
-            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
-            'dates' => [$d1, $d2],
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBefore($futureDate),
+            Query::limit(1)
+        ]);
 
-        // Regression: reading a datetime (object) array used to throw in Mongo with
-        // "Cannot use object of type MongoDB\BSON\UTCDateTime as array" because the
-        // Document constructor tried to array-access non-array elements.
-        $doc = $database->getDocument($collection, 'doc1');
-        $dates = $doc->getAttribute('dates');
-        $this->assertIsArray($dates);
-        $this->assertCount(2, $dates);
-        $this->assertEquals($d1, $dates[0]);
-        $this->assertEquals($d2, $dates[1]);
+        $this->assertGreaterThan(0, count($documents));
 
-        // Same values must round-trip through find()
-        $found = $database->find($collection, [Query::equal('$id', ['doc1'])]);
-        $this->assertCount(1, $found);
-        $this->assertEquals([$d1, $d2], $found[0]->getAttribute('dates'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBefore($pastDate),
+            Query::limit(1)
+        ]);
 
-        $database->deleteCollection($collection);
+        $this->assertEquals(0, count($documents));
     }
 
-    public function testInvalidCreatedAndUpdatedAtThrowStructureException(): void
+    public function testFindCreatedAfter(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'invalid_date_attributes';
-
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
-
-        $database->setPreserveDates(true);
+        /**
+         * Test Query::createdAfter wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        try {
-            // Outside allowed year range (Structure uses DatetimeValidator min/max, e.g. 0000–9999).
-            $invalidDate = '10000-01-01T00:00:00.000+00:00';
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdAfter($pastDate),
+            Query::limit(1)
+        ]);
 
-            try {
-                $database->createDocument($collection, new Document([
-                    '$id' => 'doc1',
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::update(Role::any()),
-                    ],
-                    '$createdAt' => $invalidDate,
-                ]));
-                $this->fail('Expected StructureException for invalid $createdAt');
-            } catch (Throwable $e) {
-                $this->assertInstanceOf(StructureException::class, $e);
-            }
+        $this->assertGreaterThan(0, count($documents));
 
-            $database->createDocument($collection, new Document([
-                '$id' => 'doc2',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                ],
-                'string' => 'x',
-            ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdAfter($futureDate),
+            Query::limit(1)
+        ]);
 
-            try {
-                $database->updateDocument($collection, 'doc2', new Document([
-                    '$updatedAt' => $invalidDate,
-                ]));
-                $this->fail('Expected StructureException for invalid $updatedAt');
-            } catch (Throwable $e) {
-                $this->assertInstanceOf(StructureException::class, $e);
-            }
-        } finally {
-            $database->setPreserveDates(false);
-            $database->deleteCollection($collection);
-        }
+        $this->assertEquals(0, count($documents));
     }
 
-    public function testSingleDocumentDateOperations(): void
+    public function testFindUpdatedBefore(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
-        $collection = 'normal_date_operations';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
 
-        $database->setPreserveDates(true);
+        /**
+         * Test Query::updatedBefore wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        $createDate = '2000-01-01T10:00:00.000+00:00';
-        $updateDate = '2000-02-01T15:30:00.000+00:00';
-        $date1 = '2000-01-01T10:00:00.000+00:00';
-        $date2 = '2000-02-01T15:30:00.000+00:00';
-        $date3 = '2000-03-01T20:45:00.000+00:00';
-        // Test 1: Create with custom createdAt, then update with custom updatedAt
-        $doc = $database->createDocument($collection, new Document([
-            '$id' => 'doc1',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'initial',
-            '$createdAt' => $createDate
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBefore($futureDate),
+            Query::limit(1)
+        ]);
 
-        $this->assertEquals($createDate, $doc->getAttribute('$createdAt'));
-        $this->assertNotEquals($createDate, $doc->getAttribute('$updatedAt'));
+        $this->assertGreaterThan(0, count($documents));
 
-        // Update with custom updatedAt
-        $doc->setAttribute('string', 'updated');
-        $doc->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc = $database->updateDocument($collection, 'doc1', $doc);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBefore($pastDate),
+            Query::limit(1)
+        ]);
 
-        $this->assertEquals($createDate, $updatedDoc->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedDoc->getAttribute('$updatedAt'));
+        $this->assertEquals(0, count($documents));
+    }
 
-        // Test 2: Create with both custom dates
-        $doc2 = $database->createDocument($collection, new Document([
-            '$id' => 'doc2',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'both_dates',
-            '$createdAt' => $createDate,
-            '$updatedAt' => $updateDate
-        ]));
+    public function testFindUpdatedAfter(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals($createDate, $doc2->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $doc2->getAttribute('$updatedAt'));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Test 3: Create without dates, then update with custom dates
-        $doc3 = $database->createDocument($collection, new Document([
-            '$id' => 'doc3',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'no_dates'
-        ]));
+        /**
+         * Test Query::updatedAfter wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedAfter($pastDate),
+            Query::limit(1)
+        ]);
 
-        $doc3->setAttribute('string', 'updated_no_dates');
-        $doc3->setAttribute('$createdAt', $createDate);
-        $doc3->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc3 = $database->updateDocument($collection, 'doc3', $doc3);
+        $this->assertGreaterThan(0, count($documents));
 
-        $this->assertEquals($createDate, $updatedDoc3->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedDoc3->getAttribute('$updatedAt'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedAfter($futureDate),
+            Query::limit(1)
+        ]);
 
-        // Test 4: Update only createdAt
-        $doc4 = $database->createDocument($collection, new Document([
-            '$id' => 'doc4',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'initial'
-        ]));
+        $this->assertEquals(0, count($documents));
+    }
 
-        $originalCreatedAt4 = $doc4->getAttribute('$createdAt');
-        $originalUpdatedAt4 = $doc4->getAttribute('$updatedAt');
+    public function testFindCreatedBetween(): void
+    {
+        $this->initMoviesFixture();
 
-        sleep(1); // Ensure $updatedAt differs when adapter timestamp precision is seconds
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $doc4->setAttribute('$updatedAt', null);
-        $doc4->setAttribute('$createdAt', null);
-        $updatedDoc4 = $database->updateDocument($collection, 'doc4', document: $doc4);
+        /**
+         * Test Query::createdBetween wrapper
+         */
+        $pastDate = '1900-01-01T00:00:00.000Z';
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $recentPastDate = '2020-01-01T00:00:00.000Z';
+        $nearFutureDate = '2025-01-01T00:00:00.000Z';
 
-        $this->assertEquals($originalCreatedAt4, $updatedDoc4->getAttribute('$createdAt'));
-        $this->assertNotEquals($originalUpdatedAt4, $updatedDoc4->getAttribute('$updatedAt'));
+        // All documents should be between past and future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $futureDate),
+            Query::limit(25)
+        ]);
 
-        // Test 5: Update only updatedAt
-        $updatedDoc4->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc4->setAttribute('$createdAt', $createDate);
-        $finalDoc4 = $database->updateDocument($collection, 'doc4', $updatedDoc4);
+        $this->assertGreaterThan(0, count($documents));
 
-        $this->assertEquals($createDate, $finalDoc4->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $finalDoc4->getAttribute('$updatedAt'));
+        // No documents should exist in this range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $pastDate),
+            Query::limit(25)
+        ]);
 
-        // Test 6: Create with updatedAt, update with createdAt
-        $doc5 = $database->createDocument($collection, new Document([
-            '$id' => 'doc5',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'doc5',
-            '$updatedAt' => $date2
-        ]));
+        $this->assertEquals(0, count($documents));
 
-        $this->assertNotEquals($date2, $doc5->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $doc5->getAttribute('$updatedAt'));
+        // Documents created between recent past and near future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($recentPastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
 
-        $doc5->setAttribute('string', 'doc5_updated');
-        $doc5->setAttribute('$createdAt', $date1);
-        $updatedDoc5 = $database->updateDocument($collection, 'doc5', $doc5);
+        $count = count($documents);
 
-        $this->assertEquals($date1, $updatedDoc5->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $updatedDoc5->getAttribute('$updatedAt'));
+        // Same count should be returned with expanded range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
 
-        // Test 7: Create with both dates, update with different dates
-        $doc6 = $database->createDocument($collection, new Document([
-            '$id' => 'doc6',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'doc6',
-            '$createdAt' => $date1,
-            '$updatedAt' => $date2
-        ]));
+        $this->assertGreaterThanOrEqual($count, count($documents));
+    }
 
-        $this->assertEquals($date1, $doc6->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $doc6->getAttribute('$updatedAt'));
+    public function testFindUpdatedBetween(): void
+    {
+        $this->initMoviesFixture();
 
-        $doc6->setAttribute('string', 'doc6_updated');
-        $doc6->setAttribute('$createdAt', $date3);
-        $doc6->setAttribute('$updatedAt', $date3);
-        $updatedDoc6 = $database->updateDocument($collection, 'doc6', $doc6);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals($date3, $updatedDoc6->getAttribute('$createdAt'));
-        $this->assertEquals($date3, $updatedDoc6->getAttribute('$updatedAt'));
+        /**
+         * Test Query::updatedBetween wrapper
+         */
+        $pastDate = '1900-01-01T00:00:00.000Z';
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $recentPastDate = '2020-01-01T00:00:00.000Z';
+        $nearFutureDate = '2025-01-01T00:00:00.000Z';
 
-        // Test 8: Preserve dates disabled
-        $database->setPreserveDates(false);
+        // All documents should be between past and future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $futureDate),
+            Query::limit(25)
+        ]);
 
-        $customDate = '2000-01-01T10:00:00.000+00:00';
+        $this->assertGreaterThan(0, count($documents));
 
-        $doc7 = $database->createDocument($collection, new Document([
-            '$id' => 'doc7',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'doc7',
-            '$createdAt' => $customDate,
-            '$updatedAt' => $customDate
-        ]));
+        // No documents should exist in this range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $pastDate),
+            Query::limit(25)
+        ]);
 
-        $this->assertNotEquals($customDate, $doc7->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $doc7->getAttribute('$updatedAt'));
+        $this->assertEquals(0, count($documents));
 
-        // Update with custom dates should also be ignored
-        $doc7->setAttribute('string', 'updated');
-        $doc7->setAttribute('$createdAt', $customDate);
-        $doc7->setAttribute('$updatedAt', $customDate);
-        $updatedDoc7 = $database->updateDocument($collection, 'doc7', $doc7);
+        // Documents updated between recent past and near future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($recentPastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
 
-        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$updatedAt'));
+        $count = count($documents);
 
-        // Test checking updatedAt updates even old document exists
-        $database->setPreserveDates(true);
-        $doc11 = $database->createDocument($collection, new Document([
-            '$id' => 'doc11',
-            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
-            'string' => 'no_dates',
-            '$createdAt' => $customDate
-        ]));
-
-        $newUpdatedAt = $doc11->getUpdatedAt();
-
-        \usleep(2000); // Ensure $updatedAt differs when adapter timestamp precision is milliseconds
-
-        $newDoc11 = new Document([
-            'string' => 'no_dates_update',
+        // Same count should be returned with expanded range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $nearFutureDate),
+            Query::limit(25)
         ]);
-        $updatedDoc7 = $database->updateDocument($collection, 'doc11', $newDoc11);
-        $this->assertNotEquals($newUpdatedAt, $updatedDoc7->getAttribute('$updatedAt'));
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+        $this->assertGreaterThanOrEqual($count, count($documents));
     }
 
-    public function testBulkDocumentDateOperations(): void
+    public function testFindLimit(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
-        $collection = 'bulk_date_operations';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
 
-        $database->setPreserveDates(true);
+        /**
+         * Limit
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(4),
+            Query::offset(0),
+            Query::orderAsc('name')
+        ]);
 
-        $createDate = '2000-01-01T10:00:00.000+00:00';
-        $updateDate = '2000-02-01T15:30:00.000+00:00';
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
+        $this->assertEquals(4, count($documents));
+        $this->assertEquals('Captain America: The First Avenger', $documents[0]['name']);
+        $this->assertEquals('Captain Marvel', $documents[1]['name']);
+        $this->assertEquals('Frozen', $documents[2]['name']);
+        $this->assertEquals('Frozen II', $documents[3]['name']);
+    }
 
-        // Test 1: Bulk create with different date configurations
-        $documents = [
-            new Document([
-                '$id' => 'doc1',
-                '$permissions' => $permissions,
-                'string' => 'doc1',
-                '$createdAt' => $createDate
-            ]),
-            new Document([
-                '$id' => 'doc2',
-                '$permissions' => $permissions,
-                'string' => 'doc2',
-                '$updatedAt' => $updateDate
-            ]),
-            new Document([
-                '$id' => 'doc3',
-                '$permissions' => $permissions,
-                'string' => 'doc3',
-                '$createdAt' => $createDate,
-                '$updatedAt' => $updateDate
-            ]),
-            new Document([
-                '$id' => 'doc4',
-                '$permissions' => $permissions,
-                'string' => 'doc4'
-            ]),
-            new Document([
-                '$id' => 'doc5',
-                '$permissions' => $permissions,
-                'string' => 'doc5',
-                '$createdAt' => null
-            ]),
-            new Document([
-                '$id' => 'doc6',
-                '$permissions' => $permissions,
-                'string' => 'doc6',
-                '$updatedAt' => null
-            ])
-        ];
+    public function testFindLimitAndOffset(): void
+    {
+        $this->initMoviesFixture();
 
-        $database->createDocuments($collection, $documents);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Verify initial state
-        foreach (['doc1', 'doc3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
-        }
+        /**
+         * Limit + Offset
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(4),
+            Query::offset(2),
+            Query::orderAsc('name')
+        ]);
 
-        foreach (['doc2', 'doc3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-        }
+        $this->assertEquals(4, count($documents));
+        $this->assertEquals('Frozen', $documents[0]['name']);
+        $this->assertEquals('Frozen II', $documents[1]['name']);
+        $this->assertEquals('Work in Progress', $documents[2]['name']);
+        $this->assertEquals('Work in Progress 2', $documents[3]['name']);
+    }
 
-        foreach (['doc4', 'doc5', 'doc6'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt missing for $id");
-            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt missing for $id");
-        }
+    public function testFindOrQueries(): void
+    {
+        $this->initMoviesFixture();
 
-        // Test 2: Bulk update with custom dates
-        $updateDoc = new Document([
-            'string' => 'updated',
-            '$createdAt' => $createDate,
-            '$updatedAt' => $updateDate
-        ]);
-        $ids = [];
-        foreach ($documents as $doc) {
-            $ids[] = $doc->getId();
-        }
-        $count = $database->updateDocuments($collection, $updateDoc, [
-            Query::equal('$id', $ids)
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        /**
+         * Test that OR queries are handled correctly
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD', 'Joe Johnston']),
+            Query::equal('year', [2025]),
         ]);
-        $this->assertEquals(6, $count);
+        $this->assertEquals(1, count($documents));
+    }
+    public function testFindEdgeCases(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        foreach (['doc1', 'doc3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-            $this->assertEquals('updated', $doc->getAttribute('string'), "string mismatch for $id");
-        }
+        $collection = 'edgeCases';
 
-        foreach (['doc2', 'doc4','doc5','doc6'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-            $this->assertEquals('updated', $doc->getAttribute('string'), "string mismatch for $id");
-        }
+        $database->createCollection(new Collection(id: $collection));
 
-        // Test 3: Bulk update with preserve dates disabled
-        $database->setPreserveDates(false);
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'value', size: 256, required: true)));
 
-        $customDate = 'should be ignored anyways so no error';
-        $updateDocDisabled = new Document([
-            'string' => 'disabled_update',
-            '$createdAt' => $customDate,
-            '$updatedAt' => $customDate
-        ]);
+        $values = [
+            'NormalString',
+            '{"type":"json","somekey":"someval"}',
+            '{NormalStringInBraces}',
+            '"NormalStringInDoubleQuotes"',
+            '{"NormalStringInDoubleQuotesAndBraces"}',
+            "'NormalStringInSingleQuotes'",
+            "{'NormalStringInSingleQuotesAndBraces'}",
+            "SingleQuote'InMiddle",
+            'DoubleQuote"InMiddle',
+            'Slash/InMiddle',
+            'Backslash\InMiddle',
+            'Colon:InMiddle',
+            '"quoted":"colon"'
+        ];
 
-        $countDisabled = $database->updateDocuments($collection, $updateDocDisabled);
-        $this->assertEquals(6, $countDisabled);
+        foreach ($values as $value) {
+            $database->createDocument($collection, new Document([
+                '$id' => ID::unique(),
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                    Permission::update(Role::any()),
+                    Permission::delete(Role::any())
+                ],
+                'value' => $value
+            ]));
+        }
 
-        // Test 4: Bulk update with preserve dates re-enabled
-        $database->setPreserveDates(true);
+        /**
+         * Check Basic
+         */
+        $documents = $database->find($collection);
 
-        $newDate = '2000-03-01T20:45:00.000+00:00';
-        $updateDocEnabled = new Document([
-            'string' => 'enabled_update',
-            '$createdAt' => $newDate,
-            '$updatedAt' => $newDate
-        ]);
+        $this->assertEquals(count($values), count($documents));
+        $this->assertNotEmpty($documents[0]->getId());
+        $this->assertEquals($collection, $documents[0]->getCollection());
+        $this->assertEquals(['any'], $documents[0]->getRead());
+        $this->assertEquals(['any'], $documents[0]->getUpdate());
+        $this->assertEquals(['any'], $documents[0]->getDelete());
+        $this->assertEquals($values[0], $documents[0]->getAttribute('value'));
 
-        $countEnabled = $database->updateDocuments($collection, $updateDocEnabled);
-        $this->assertEquals(6, $countEnabled);
+        /**
+         * Check `equals` query
+         */
+        foreach ($values as $value) {
+            $documents = $database->find($collection, [
+                Query::limit(25),
+                Query::equal('value', [$value])
+            ]);
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+            $this->assertEquals(1, count($documents));
+            $this->assertEquals($value, $documents[0]->getAttribute('value'));
+        }
     }
 
-    public function testUpsertDateOperations(): void
+    public function testNestedIDQueries(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $collection = 'upsert_date_operations';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
+        $database->createCollection(new Collection(id: 'movies_nested_id', permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users())
+        ]));
 
-        $database->setPreserveDates(true);
+        $this->assertEquals(true, $database->createAttribute('movies_nested_id', Attribute::string(key: 'name', size: 128, required: true)));
 
-        $createDate = '2000-01-01T10:00:00.000+00:00';
-        $updateDate = '2000-02-01T15:30:00.000+00:00';
-        $date1 = '2000-01-01T10:00:00.000+00:00';
-        $date2 = '2000-02-01T15:30:00.000+00:00';
-        $date3 = '2000-03-01T20:45:00.000+00:00';
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
+        $database->createDocument('movies_nested_id', new Document([
+            '$id' => ID::custom('1'),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => '1',
+        ]));
 
-        // Test 1: Upsert new document with custom createdAt
-        $upsertResults = [];
-        $database->upsertDocuments($collection, [
-            new Document([
-                '$id' => 'upsert1',
-                '$permissions' => $permissions,
-                'string' => 'upsert1_initial',
-                '$createdAt' => $createDate
-            ])
-        ], onNext: function ($doc) use (&$upsertResults) {
-            $upsertResults[] = $doc;
-        });
-        $upsertDoc1 = $upsertResults[0];
-
-        $this->assertEquals($createDate, $upsertDoc1->getAttribute('$createdAt'));
-        $this->assertNotEquals($createDate, $upsertDoc1->getAttribute('$updatedAt'));
-
-        // Test 2: Upsert existing document with custom updatedAt
-        $upsertDoc1->setAttribute('string', 'upsert1_updated');
-        $upsertDoc1->setAttribute('$updatedAt', $updateDate);
-        $updatedUpsertResults = [];
-        $database->upsertDocuments($collection, [$upsertDoc1], onNext: function ($doc) use (&$updatedUpsertResults) {
-            $updatedUpsertResults[] = $doc;
-        });
-        $updatedUpsertDoc1 = $updatedUpsertResults[0];
+        $database->createDocument('movies_nested_id', new Document([
+            '$id' => ID::custom('2'),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => '2',
+        ]));
 
-        $this->assertEquals($createDate, $updatedUpsertDoc1->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedUpsertDoc1->getAttribute('$updatedAt'));
+        $database->createDocument('movies_nested_id', new Document([
+            '$id' => ID::custom('3'),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => '3',
+        ]));
 
-        // Test 3: Upsert new document with both custom dates
-        $upsertResults2 = [];
-        $database->upsertDocuments($collection, [
-            new Document([
-                '$id' => 'upsert2',
-                '$permissions' => $permissions,
-                'string' => 'upsert2_both_dates',
-                '$createdAt' => $createDate,
-                '$updatedAt' => $updateDate
+        $queries = [
+            Query::or([
+                Query::equal('$id', ["1"]),
+                Query::equal('$id', ["2"])
             ])
-        ], onNext: function ($doc) use (&$upsertResults2) {
-            $upsertResults2[] = $doc;
-        });
-        $upsertDoc2 = $upsertResults2[0];
-
-        $this->assertEquals($createDate, $upsertDoc2->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $upsertDoc2->getAttribute('$updatedAt'));
+        ];
 
-        // Test 4: Upsert existing document with different dates
-        $upsertDoc2->setAttribute('string', 'upsert2_updated');
-        $upsertDoc2->setAttribute('$createdAt', $date3);
-        $upsertDoc2->setAttribute('$updatedAt', $date3);
-        $updatedUpsertResults2 = [];
-        $database->upsertDocuments($collection, [$upsertDoc2], onNext: function ($doc) use (&$updatedUpsertResults2) {
-            $updatedUpsertResults2[] = $doc;
-        });
-        $updatedUpsertDoc2 = $updatedUpsertResults2[0];
+        $documents = $database->find('movies_nested_id', $queries);
+        $this->assertCount(2, $documents);
 
-        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$createdAt'));
-        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$updatedAt'));
+        // Make sure the query was not modified by reference
+        $nested = $queries[0]->getValues()[0];
+        $this->assertInstanceOf(Query::class, $nested);
+        $this->assertEquals($nested->getAttribute(), '$id');
 
-        // Test 5: Upsert with preserve dates disabled
-        $database->setPreserveDates(false);
+        $count = $database->count('movies_nested_id', $queries);
+        $this->assertEquals(2, $count);
+    }
 
-        $customDate = '2000-01-01T10:00:00.000+00:00';
-        $upsertResults3 = [];
-        $database->upsertDocuments($collection, [
-            new Document([
-                '$id' => 'upsert3',
-                '$permissions' => $permissions,
-                'string' => 'upsert3_disabled',
-                '$createdAt' => $customDate,
-                '$updatedAt' => $customDate
-            ])
-        ], onNext: function ($doc) use (&$upsertResults3) {
-            $upsertResults3[] = $doc;
-        });
-        $upsertDoc3 = $upsertResults3[0];
+    public function testFindNotBetween(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$updatedAt'));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Update with custom dates should also be ignored
-        $upsertDoc3->setAttribute('string', 'upsert3_updated');
-        $upsertDoc3->setAttribute('$createdAt', $customDate);
-        $upsertDoc3->setAttribute('$updatedAt', $customDate);
-        $updatedUpsertResults3 = [];
-        $database->upsertDocuments($collection, [$upsertDoc3], onNext: function ($doc) use (&$updatedUpsertResults3) {
-            $updatedUpsertResults3[] = $doc;
-        });
-        $updatedUpsertDoc3 = $updatedUpsertResults3[0];
+        // Test notBetween with price range - should return documents outside the range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('price', 25.94, 25.99),
+        ]);
+        $this->assertEquals(4, count($documents)); // All movies except the 2 in the price range
 
-        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$updatedAt'));
+        // Test notBetween with range that includes no documents - should return all documents
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('price', 30, 35),
+        ]);
+        $this->assertEquals(6, count($documents));
 
-        // Test 6: Bulk upsert operations with custom dates
-        $database->setPreserveDates(true);
+        // Test notBetween with date range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('$createdAt', '1975-12-06', '2050-12-06'),
+        ]);
+        $this->assertEquals(0, count($documents)); // No movies outside this wide date range
 
-        // Test 7: Bulk upsert with different date configurations
-        $upsertDocuments = [
-            new Document([
-                '$id' => 'bulk_upsert1',
-                '$permissions' => $permissions,
-                'string' => 'bulk_upsert1_initial',
-                '$createdAt' => $createDate
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert2',
-                '$permissions' => $permissions,
-                'string' => 'bulk_upsert2_initial',
-                '$updatedAt' => $updateDate
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert3',
-                '$permissions' => $permissions,
-                'string' => 'bulk_upsert3_initial',
-                '$createdAt' => $createDate,
-                '$updatedAt' => $updateDate
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert4',
-                '$permissions' => $permissions,
-                'string' => 'bulk_upsert4_initial'
-            ])
-        ];
+        // Test notBetween with narrower date range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('$createdAt', '2000-01-01', '2001-01-01'),
+        ]);
+        $this->assertEquals(6, count($documents)); // All movies should be outside this narrow range
 
-        $bulkUpsertResults = [];
-        $database->upsertDocuments($collection, $upsertDocuments, onNext: function ($doc) use (&$bulkUpsertResults) {
-            $bulkUpsertResults[] = $doc;
-        });
+        // Test notBetween with updated date range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('$updatedAt', '2000-01-01T00:00:00.000+00:00', '2001-01-01T00:00:00.000+00:00'),
+        ]);
+        $this->assertEquals(6, count($documents)); // All movies should be outside this narrow range
 
-        // Test 8: Verify initial bulk upsert state
-        foreach (['bulk_upsert1', 'bulk_upsert3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
-        }
+        // Test notBetween with year range (integer values)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('year', 2005, 2007),
+        ]);
+        $this->assertLessThanOrEqual(6, count($documents)); // Movies outside 2005-2007 range
 
-        foreach (['bulk_upsert2', 'bulk_upsert3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-        }
+        // Test notBetween with reversed range (start > end) - should still work
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('price', 25.99, 25.94), // Note: reversed order
+        ]);
+        $this->assertGreaterThanOrEqual(4, count($documents)); // Should handle reversed range gracefully
 
-        foreach (['bulk_upsert4'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt missing for $id");
-            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt missing for $id");
-        }
+        // Test notBetween with same start and end values
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('year', 2006, 2006),
+        ]);
+        $this->assertGreaterThanOrEqual(5, count($documents)); // All movies except those from exactly 2006
 
-        // Test 9: Bulk upsert update with custom dates using updateDocuments
-        $newDate = '2000-04-01T12:00:00.000+00:00';
-        $updateUpsertDoc = new Document([
-            'string' => 'bulk_upsert_updated',
-            '$createdAt' => $newDate,
-            '$updatedAt' => $newDate
+        // Test notBetween combined with other filters
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('price', 25.94, 25.99),
+            Query::orderDesc('year'),
+            Query::limit(2)
         ]);
+        $this->assertEquals(2, count($documents)); // Limited results, ordered, excluding price range
 
-        $upsertIds = [];
-        foreach ($upsertDocuments as $doc) {
-            $upsertIds[] = $doc->getId();
-        }
+        // Test notBetween with extreme ranges
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('year', -1000, 1000), // Very wide range
+        ]);
+        $this->assertLessThanOrEqual(6, count($documents)); // Movies outside this range
 
-        $database->updateDocuments($collection, $updateUpsertDoc, [
-            Query::equal('$id', $upsertIds)
+        // Test notBetween with float precision
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('price', 25.945, 25.955), // Very narrow range
         ]);
+        $this->assertGreaterThanOrEqual(4, count($documents)); // Most movies should be outside this narrow range
+    }
 
-        foreach ($upsertIds as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($newDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
-            $this->assertEquals($newDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-            $this->assertEquals('bulk_upsert_updated', $doc->getAttribute('string'), "string mismatch for $id");
-        }
+    public function testFindSelect(): void
+    {
+        $this->initMoviesFixture();
 
-        // Test 10: checking by passing null to each
-        $updateUpsertDoc = new Document([
-            'string' => 'bulk_upsert_updated',
-            '$createdAt' => null,
-            '$updatedAt' => null
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year'])
         ]);
 
-        $upsertIds = [];
-        foreach ($upsertDocuments as $doc) {
-            $upsertIds[] = $doc->getId();
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        $database->updateDocuments($collection, $updateUpsertDoc, [
-            Query::equal('$id', $upsertIds)
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$id'])
         ]);
 
-        foreach ($upsertIds as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
-            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        // Test 11: Bulk upsert operations with upsertDocuments
-        $upsertUpdateDocuments = [];
-        foreach ($upsertDocuments as $doc) {
-            $updatedDoc = clone $doc;
-            $updatedDoc->setAttribute('string', 'bulk_upsert_updated_via_upsert');
-            $updatedDoc->setAttribute('$createdAt', $newDate);
-            $updatedDoc->setAttribute('$updatedAt', $newDate);
-            $upsertUpdateDocuments[] = $updatedDoc;
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$sequence'])
+        ]);
+
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        $upsertUpdateResults = [];
-        $countUpsertUpdate = $database->upsertDocuments($collection, $upsertUpdateDocuments, onNext: function ($doc) use (&$upsertUpdateResults) {
-            $upsertUpdateResults[] = $doc;
-        });
-        $this->assertEquals(4, $countUpsertUpdate);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$collection'])
+        ]);
 
-        foreach ($upsertUpdateResults as $doc) {
-            $this->assertEquals($newDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for upsert update");
-            $this->assertEquals($newDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for upsert update");
-            $this->assertEquals('bulk_upsert_updated_via_upsert', $doc->getAttribute('string'), "string mismatch for upsert update");
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        // Test 12: Bulk upsert with preserve dates disabled
-        $database->setPreserveDates(false);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$createdAt'])
+        ]);
 
-        $customDate = 'should be ignored anyways so no error';
-        $upsertDisabledDocuments = [];
-        foreach ($upsertDocuments as $doc) {
-            $disabledDoc = clone $doc;
-            $disabledDoc->setAttribute('string', 'bulk_upsert_disabled');
-            $disabledDoc->setAttribute('$createdAt', $customDate);
-            $disabledDoc->setAttribute('$updatedAt', $customDate);
-            $upsertDisabledDocuments[] = $disabledDoc;
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        $upsertDisabledResults = [];
-        $countUpsertDisabled = $database->upsertDocuments($collection, $upsertDisabledDocuments, onNext: function ($doc) use (&$upsertDisabledResults) {
-            $upsertDisabledResults[] = $doc;
-        });
-        $this->assertEquals(4, $countUpsertDisabled);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$updatedAt'])
+        ]);
 
-        foreach ($upsertDisabledResults as $doc) {
-            $this->assertNotEquals($customDate, $doc->getAttribute('$createdAt'), "createdAt should not be custom date when disabled");
-            $this->assertNotEquals($customDate, $doc->getAttribute('$updatedAt'), "updatedAt should not be custom date when disabled");
-            $this->assertEquals('bulk_upsert_disabled', $doc->getAttribute('string'), "string mismatch for disabled upsert");
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
         }
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$permissions'])
+        ]);
+
+        foreach ($documents as $document) {
+            $this->assertArrayHasKey('name', $document);
+            $this->assertArrayHasKey('year', $document);
+            $this->assertArrayNotHasKey('director', $document);
+            $this->assertArrayNotHasKey('price', $document);
+            $this->assertArrayNotHasKey('active', $document);
+            $this->assertArrayHasKey('$id', $document);
+            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayHasKey('$collection', $document);
+            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayHasKey('$permissions', $document);
+        }
     }
 
-    public function testUpdateDocumentsCount(): void
+    #[Depends('testFindCheckPermissions')]
+    public function testForeach(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        /**
+         * Test, foreach generator on empty collection
+         */
+        $database->createCollection(new Collection(id: 'moviesEmpty'));
+        $documents = [];
+        foreach ($database->iterate('moviesEmpty', queries: [Query::limit(2)]) as $document) {
+            $documents[] = $document;
         }
+        $this->assertEquals(0, \count($documents));
+        $this->assertTrue($database->deleteCollection('moviesEmpty'));
 
-        $collectionName = "update_count";
-        $database->createCollection($collectionName);
+        /**
+         * Test, foreach generator
+         */
+        $documents = [];
+        foreach ($database->iterate($this->getMoviesCollection(), queries: [Query::limit(2)]) as $document) {
+            $documents[] = $document;
+        }
+        $this->assertEquals(6, count($documents));
 
-        $database->createAttribute($collectionName, 'key', Database::VAR_STRING, 60, false);
-        $database->createAttribute($collectionName, 'value', Database::VAR_STRING, 60, false);
+        /**
+         * Test, foreach goes through all the documents
+         */
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
+        });
+        $this->assertEquals(6, count($documents));
 
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
+        /**
+         * Test, foreach with initial cursor
+         */
 
-        $docs =  [
-            new Document([
-                '$id' => 'bulk_upsert1',
-                '$permissions' => $permissions,
-                'key' => 'bulk_upsert1_initial',
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert2',
-                '$permissions' => $permissions,
-                'key' => 'bulk_upsert2_initial',
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert3',
-                '$permissions' => $permissions,
-                'key' => 'bulk_upsert3_initial',
-            ]),
-            new Document([
-                '$id' => 'bulk_upsert4',
-                '$permissions' => $permissions,
-                'key' => 'bulk_upsert4_initial'
-            ])
-        ];
-        $upsertUpdateResults = [];
-        $count = $database->upsertDocuments($collectionName, $docs, onNext: function ($doc) use (&$upsertUpdateResults) {
-            $upsertUpdateResults[] = $doc;
+        $first = $documents[0];
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2), Query::cursorAfter($first)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
         });
-        $this->assertCount(4, $upsertUpdateResults);
-        $this->assertEquals(4, $count);
+        $this->assertEquals(5, count($documents));
 
-        $updates = new Document(['value' => 'test']);
-        $newDocs = [];
-        $count = $database->updateDocuments($collectionName, $updates, onNext:function ($doc) use (&$newDocs) {
-            $newDocs[] = $doc;
+        /**
+         * Test, foreach with initial offset
+         */
+
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2), Query::offset(2)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
         });
+        $this->assertEquals(4, count($documents));
 
-        $this->assertCount(4, $newDocs);
-        $this->assertEquals(4, $count);
+        /**
+         * Test, cursor before throws error
+         */
+        try {
+            $database->foreach($this->getMoviesCollection(), queries: [Query::cursorBefore($documents[0]), Query::offset(2)], callback: function ($document) use (&$documents) {
+                $documents[] = $document;
+            });
 
-        $database->deleteCollection($collectionName);
-    }
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DatabaseException::class, $e);
+            $this->assertEquals('Cursor ' . CursorDirection::Before->value . ' not supported in this method.', $e->getMessage());
+        }
 
-    public function testCreateUpdateDocumentsMismatch(): void
+    }
+    public function testCount(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        // with different set of attributes
-        $colName = "docs_with_diff";
-        $database->createCollection($colName);
-        $database->createAttribute($colName, 'key', Database::VAR_STRING, 50, true);
-        $database->createAttribute($colName, 'value', Database::VAR_STRING, 50, false, 'value');
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
-        $docs =  [
-            new Document([
-                '$id' => 'doc1',
-                'key' => 'doc1',
-            ]),
-            new Document([
-                '$id' => 'doc2',
-                'key' => 'doc2',
-                'value' => 'test',
-            ]),
-            new Document([
-                '$id' => 'doc3',
-                '$permissions' => $permissions,
-                'key' => 'doc3'
-            ]),
-        ];
-        $this->assertEquals(3, $database->createDocuments($colName, $docs));
-        // we should get only one document as read permission provided to the last document only
-        $addedDocs = $database->find($colName);
-        $this->assertCount(1, $addedDocs);
-        $doc = $addedDocs[0];
-        $this->assertEquals('doc3', $doc->getId());
-        $this->assertNotEmpty($doc->getPermissions());
-        $this->assertCount(3, $doc->getPermissions());
-
-        $database->createDocument($colName, new Document([
-            '$id' => 'doc4',
-            '$permissions' => $permissions,
-            'key' => 'doc4'
-        ]));
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(6, $count);
+        $count = $database->count($this->getMoviesCollection(), [Query::equal('year', [2019])]);
 
-        $this->assertEquals(2, $database->updateDocuments($colName, new Document(['key' => 'new doc'])));
-        $doc = $database->getDocument($colName, 'doc4');
-        $this->assertEquals('doc4', $doc->getId());
-        $this->assertEquals('value', $doc->getAttribute('value'));
+        $this->assertEquals(2, $count);
+        $count = $database->count($this->getMoviesCollection(), [Query::equal('with-dash', ['Works'])]);
+        $this->assertEquals(2, $count);
+        $count = $database->count($this->getMoviesCollection(), [Query::equal('with-dash', ['Works2', 'Works3'])]);
+        $this->assertEquals(4, $count);
 
-        $addedDocs = $database->find($colName);
-        $this->assertCount(2, $addedDocs);
-        foreach ($addedDocs as $doc) {
-            $this->assertNotEmpty($doc->getPermissions());
-            $this->assertCount(3, $doc->getPermissions());
-            $this->assertEquals('value', $doc->getAttribute('value'));
-        }
-        $database->deleteCollection($colName);
-    }
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(5, $count);
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
 
-    public function testBypassStructureWithSupportForAttributes(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-        // for schemaless the validation will be automatically skipped
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
+        $this->getDatabase()->getAuthorization()->disable();
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(6, $count);
+        $this->getDatabase()->getAuthorization()->reset();
 
-        $collectionId = 'successive_update_single';
-
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'attrA', Database::VAR_STRING, 50, true);
-        $database->createAttribute($collectionId, 'attrB', Database::VAR_STRING, 50, true);
-
-        // bypass required
-        $database->disableValidation();
+        $this->getDatabase()->getAuthorization()->disable();
+        $count = $database->count($this->getMoviesCollection(), [], 3);
+        $this->assertEquals(3, $count);
+        $this->getDatabase()->getAuthorization()->reset();
 
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())];
-        $docs = $database->createDocuments($collectionId, [
-            new Document(['attrA' => null,'attrB' => 'B','$permissions' => $permissions])
+        /**
+         * Test that OR queries are handled correctly
+         */
+        $this->getDatabase()->getAuthorization()->disable();
+        $count = $database->count($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD', 'Joe Johnston']),
+            Query::equal('year', [2025]),
         ]);
-
-        $docs = $database->find($collectionId);
-        foreach ($docs as $doc) {
-            $this->assertArrayHasKey('attrA', $doc->getAttributes());
-            $this->assertNull($doc->getAttribute('attrA'));
-            $this->assertEquals('B', $doc->getAttribute('attrB'));
-        }
-        // reset
-        $database->enableValidation();
-
-        try {
-            $database->createDocuments($collectionId, [
-                new Document(['attrA' => null,'attrB' => 'B','$permissions' => $permissions])
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-
-        $database->deleteCollection($collectionId);
+        $this->assertEquals(1, $count);
+        $this->getDatabase()->getAuthorization()->reset();
     }
 
-    public function testValidationGuardsWithNullRequired(): void
+    public function testEncodeDecode(): void
     {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Base collection and attributes
-        $collection = 'validation_guard_all';
-        $database->createCollection($collection, permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ], documentSecurity: true);
-        $database->createAttribute($collection, 'name', Database::VAR_STRING, 32, true);
-        $database->createAttribute($collection, 'age', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute($collection, 'value', Database::VAR_INTEGER, 0, false);
+        $collection = new Document([
+            '$collection' => ID::custom(Database::METADATA),
+            '$id' => ID::custom('users'),
+            'name' => 'Users',
+            'attributes' => [
+                [
+                    '$id' => ID::custom('name'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 256,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('email'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 1024,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('status'),
+                    'type' => ColumnType::Integer,
+                    'format' => '',
+                    'size' => 0,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('password'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 16384,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('passwordUpdate'),
+                    'type' => ColumnType::Datetime,
+                    'format' => '',
+                    'size' => 0,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['datetime'],
+                ],
+                [
+                    '$id' => ID::custom('registration'),
+                    'type' => ColumnType::Datetime,
+                    'format' => '',
+                    'size' => 0,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['datetime'],
+                ],
+                [
+                    '$id' => ID::custom('emailVerification'),
+                    'type' => ColumnType::Boolean,
+                    'format' => '',
+                    'size' => 0,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('reset'),
+                    'type' => ColumnType::Boolean,
+                    'format' => '',
+                    'size' => 0,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('prefs'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 16384,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['json']
+                ],
+                [
+                    '$id' => ID::custom('sessions'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 16384,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['json'],
+                ],
+                [
+                    '$id' => ID::custom('tokens'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 16384,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['json'],
+                ],
+                [
+                    '$id' => ID::custom('memberships'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 16384,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => false,
+                    'filters' => ['json'],
+                ],
+                [
+                    '$id' => ID::custom('roles'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 128,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => true,
+                    'filters' => [],
+                ],
+                [
+                    '$id' => ID::custom('tags'),
+                    'type' => ColumnType::String,
+                    'format' => '',
+                    'size' => 128,
+                    'signed' => true,
+                    'required' => false,
+                    'array' => true,
+                    'filters' => ['json'],
+                ],
+            ],
+            'indexes' => [
+                [
+                    '$id' => ID::custom('_key_email'),
+                    'type' => IndexType::Unique,
+                    'attributes' => ['email'],
+                    'lengths' => [1024],
+                    'orders' => [OrderDirection::Asc->value],
+                ]
+            ],
+        ]);
 
-        // 1) createDocument with null required should fail when validation enabled, pass when disabled
-        try {
-            $database->createDocument($collection, new Document([
-                '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
-                'name' => null,
-                'age' => null,
-            ]));
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
+        $document = new Document([
+            '$id' => ID::custom('608fdbe51361a'),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::user('608fdbe51361a')),
+                Permission::update(Role::user('608fdbe51361a')),
+                Permission::delete(Role::user('608fdbe51361a')),
+            ],
+            'email' => 'test@example.com',
+            'emailVerification' => false,
+            'status' => 1,
+            'password' => 'randomhash',
+            'passwordUpdate' => '2000-06-12 14:12:55',
+            'registration' => '1975-06-12 14:12:55+01:00',
+            'reset' => false,
+            'name' => 'My Name',
+            'prefs' => new \stdClass(),
+            'sessions' => [],
+            'tokens' => [],
+            'memberships' => [],
+            'roles' => [
+                'admin',
+                'developer',
+                'tester',
+            ],
+            'tags' => [
+                ['$id' => '1', 'label' => 'x'],
+                ['$id' => '2', 'label' => 'y'],
+                ['$id' => '3', 'label' => 'z'],
+            ],
+        ]);
 
-        $database->disableValidation();
-        $doc = $database->createDocument($collection, new Document([
-            '$id' => 'created-null',
-            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
-            'name' => null,
-            'age' => null,
-        ]));
-        $this->assertEquals('created-null', $doc->getId());
-        $database->enableValidation();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Seed a valid document for updates
-        $valid = $database->createDocument($collection, new Document([
-            '$id' => 'valid',
-            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
-            'name' => 'ok',
-            'age' => 10,
-        ]));
-        $this->assertEquals('valid', $valid->getId());
+        $result = $database->encode($collection, $document);
 
-        // 2) updateDocument set required to null should fail when validation enabled, pass when disabled
+        $this->assertEquals('608fdbe51361a', $result->getAttribute('$id'));
+        $this->assertContains('read("any")', $result->getPermissions());
+        $this->assertContains('read("any")', $result->getPermissions());
+        $this->assertContains('any', $result->getRead());
+        $this->assertContains(Permission::create(Role::user(ID::custom('608fdbe51361a'))), $result->getPermissions());
+        $this->assertContains('user:608fdbe51361a', $result->getCreate());
+        $this->assertContains('user:608fdbe51361a', $result->getWrite());
+        $this->assertEquals('test@example.com', $result->getAttribute('email'));
+        $this->assertEquals(false, $result->getAttribute('emailVerification'));
+        $this->assertEquals(1, $result->getAttribute('status'));
+        $this->assertEquals('randomhash', $result->getAttribute('password'));
+        $this->assertEquals('2000-06-12 14:12:55.000', $result->getAttribute('passwordUpdate'));
+        $this->assertEquals('1975-06-12 13:12:55.000', $result->getAttribute('registration'));
+        $this->assertEquals(false, $result->getAttribute('reset'));
+        $this->assertEquals('My Name', $result->getAttribute('name'));
+        $this->assertEquals('{}', $result->getAttribute('prefs'));
+        $this->assertEquals('[]', $result->getAttribute('sessions'));
+        $this->assertEquals('[]', $result->getAttribute('tokens'));
+        $this->assertEquals('[]', $result->getAttribute('memberships'));
+        $this->assertEquals(['admin', 'developer', 'tester',], $result->getAttribute('roles'));
+        $this->assertEquals(['{"$id":"1","label":"x"}', '{"$id":"2","label":"y"}', '{"$id":"3","label":"z"}',], $result->getAttribute('tags'));
+
+        $result = $database->decode($collection, $document);
+
+        $this->assertEquals('608fdbe51361a', $result->getAttribute('$id'));
+        $this->assertContains('read("any")', $result->getPermissions());
+        $this->assertContains('read("any")', $result->getPermissions());
+        $this->assertContains('any', $result->getRead());
+        $this->assertContains(Permission::create(Role::user('608fdbe51361a')), $result->getPermissions());
+        $this->assertContains('user:608fdbe51361a', $result->getCreate());
+        $this->assertContains('user:608fdbe51361a', $result->getWrite());
+        $this->assertEquals('test@example.com', $result->getAttribute('email'));
+        $this->assertEquals(false, $result->getAttribute('emailVerification'));
+        $this->assertEquals(1, $result->getAttribute('status'));
+        $this->assertEquals('randomhash', $result->getAttribute('password'));
+        $this->assertEquals('2000-06-12T14:12:55.000+00:00', $result->getAttribute('passwordUpdate'));
+        $this->assertEquals('1975-06-12T13:12:55.000+00:00', $result->getAttribute('registration'));
+        $this->assertEquals(false, $result->getAttribute('reset'));
+        $this->assertEquals('My Name', $result->getAttribute('name'));
+        $this->assertEquals([], $result->getAttribute('prefs'));
+        $this->assertEquals([], $result->getAttribute('sessions'));
+        $this->assertEquals([], $result->getAttribute('tokens'));
+        $this->assertEquals([], $result->getAttribute('memberships'));
+        $this->assertEquals(['admin', 'developer', 'tester',], $result->getAttribute('roles'));
+        $this->assertEquals([
+            new Document(['$id' => '1', 'label' => 'x']),
+            new Document(['$id' => '2', 'label' => 'y']),
+            new Document(['$id' => '3', 'label' => 'z']),
+        ], $result->getAttribute('tags'));
+    }
+    public function testUpdateDocumentConflict(): void
+    {
+        $document = $this->initDocumentsFixture(__FUNCTION__);
+
+        $document->setAttribute('integer_signed', 7);
+        $result = $this->getDatabase()->withRequestTimestamp(new \DateTime(), function () use ($document) {
+            return $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
+        });
+        $this->assertEquals(7, $result->getAttribute('integer_signed'));
+
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        $document->setAttribute('integer_signed', 8);
         try {
-            $database->updateDocument($collection, 'valid', new Document([
-                'age' => null,
-            ]));
+            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($document) {
+                return $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
+            });
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
+            $this->assertTrue($e instanceof ConflictException);
+            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
         }
+    }
+    public function testDeleteDocumentConflict(): void
+    {
+        $document = $this->initDocumentsFixture(__FUNCTION__);
 
-        $database->disableValidation();
-        $updated = $database->updateDocument($collection, 'valid', new Document([
-            'age' => null,
-        ]));
-        $this->assertNull($updated->getAttribute('age'));
-        $database->enableValidation();
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        $this->expectException(ConflictException::class);
+        $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () use ($document) {
+            return $this->getDatabase()->deleteDocument($document->getCollection(), $document->getId());
+        });
+    }
+    public function testUpdateDocumentDuplicatePermissions(): void
+    {
+        $document = $this->initDocumentsFixture(__FUNCTION__);
 
-        // Seed a few valid docs for bulk update
-        for ($i = 0; $i < 2; $i++) {
-            $database->createDocument($collection, new Document([
-                '$id' => 'b' . $i,
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
-                'name' => 'ok',
-                'age' => 1,
-            ]));
-        }
+        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
 
-        // 3) updateDocuments setting required to null should fail when validation enabled, pass when disabled
-        if ($database->getAdapter()->getSupportForBatchOperations()) {
-            try {
-                $database->updateDocuments($collection, new Document([
-                    'name' => null,
-                ]));
-                $this->fail('Failed to throw exception');
-            } catch (Throwable $e) {
-                $this->assertInstanceOf(StructureException::class, $e);
-            }
+        $new
+            ->setAttribute('$permissions', Permission::read(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::read(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::create(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::create(Role::guests()), SetType::Append);
 
-            $database->disableValidation();
-            $count = $database->updateDocuments($collection, new Document([
-                'name' => null,
-            ]));
-            $this->assertGreaterThanOrEqual(3, $count); // at least the seeded docs are updated
-            $database->enableValidation();
-        }
+        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
 
-        // 4) upsertDocumentsWithIncrease with null required should fail when validation enabled, pass when disabled
-        if ($database->getAdapter()->getSupportForUpserts()) {
-            try {
-                $database->upsertDocumentsWithIncrease(
-                    collection: $collection,
-                    attribute: 'value',
-                    documents: [new Document([
-                        '$id' => 'u1',
-                        'name' => null, // required null
-                        'value' => 1,
-                    ])]
-                );
-                $this->fail('Failed to throw exception');
-            } catch (Throwable $e) {
-                $this->assertInstanceOf(StructureException::class, $e);
-            }
+        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
 
-            $database->disableValidation();
-            $ucount = $database->upsertDocumentsWithIncrease(
-                collection: $collection,
-                attribute: 'value',
-                documents: [new Document([
-                    '$id' => 'u1',
-                    'name' => null,
-                    'value' => 1,
-                ])]
-            );
-            $this->assertEquals(1, $ucount);
-            $database->enableValidation();
-        }
+        $this->assertContains('guests', $new->getRead());
+        $this->assertContains('guests', $new->getCreate());
 
-        // Cleanup
-        $database->deleteCollection($collection);
+        $database = $this->getDatabase();
+        $collection = 'dupCase';
+        $database->createCollection(new Collection(id: $collection));
+
+        $stored = $database->createDocument($collection, new Document([
+            '$id' => 'caseSensitive',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+        ]));
+
+        $stored->setAttribute('$id', 'CaseSensitive');
+        $stored
+            ->setAttribute('$permissions', Permission::read(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::read(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::create(Role::guests()), SetType::Append)
+            ->setAttribute('$permissions', Permission::create(Role::guests()), SetType::Append);
+
+        $database->updateDocument($collection, 'caseSensitive', $stored);
+
+        $updated = $database->getDocument($collection, 'caseSensitive');
+        $this->assertSame('caseSensitive', $updated->getId());
+        $this->assertContains('guests', $updated->getRead());
+        $this->assertContains('guests', $updated->getCreate());
+        $this->assertContains('any', $updated->getCreate());
     }
 
     /**
-     * SQL adapters store columns under filter(attributeId). After getDocument + decode, and after
-     * updateDocument (return value + refetch), the document must expose only schema ids (e.g.
-     * pb.e_DSS.FIRMWARE_VERSION), never the filtered alias.
+     * Test that DuplicateException messages differentiate between
+     * document ID duplicates and unique index violations.
      */
-    public function testDottedAttributeKeyGetDocumentExposesOnlySchemaKeys(): void
+    public function testDuplicateExceptionMessages(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::UniqueIndex)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        // Keep id short: MySQL/MariaDB table names are limited to 64 characters (namespace + collection).
-        $collectionId = 'dotkey_' . ID::unique();
-        $attrId = 'pb.e_DSS.FIRMWARE_VERSION';
-        $filteredStorageKey = $database->getAdapter()->filter($attrId);
+        $database->createCollection(new Collection(id: 'duplicateMessages'));
+        $database->createAttribute('duplicateMessages', Attribute::string(key: 'email', size: 128, required: true));
+        $database->createIndex('duplicateMessages', Index::unique(key: 'emailUnique', attributes: ['email'], lengths: [128]));
 
-        $database->createCollection($collectionId);
-        $this->assertTrue($database->createAttribute($collectionId, $attrId, Database::VAR_STRING, 128, false));
-
-        // Optional attribute omitted: DB column is NULL — decode must not leave the SQL column name as a key.
-        $database->createDocument($collectionId, new Document([
-            '$id' => 'dev1',
+        // Create first document
+        $database->createDocument('duplicateMessages', new Document([
+            '$id' => 'dup_msg_1',
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any()),
             ],
+            'email' => 'test@example.com',
         ]));
 
-        $doc = $database->getDocument($collectionId, 'dev1');
-        $this->assertSame('dev1', $doc->getId());
-        $this->assertNull($doc->getAttribute($attrId));
-        $this->assertArrayNotHasKey($filteredStorageKey, $doc->getAttributes());
-        $userKeys = array_keys($doc->getAttributes());
-        sort($userKeys);
-        $this->assertSame([$attrId], $userKeys);
+        // Test 1: Duplicate document ID should say "Document already exists"
+        try {
+            $database->createDocument('duplicateMessages', new Document([
+                '$id' => 'dup_msg_1',
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                ],
+                'email' => 'different@example.com',
+            ]));
+            $this->fail('Expected DuplicateException for duplicate document ID');
+        } catch (DuplicateException $e) {
+            $this->assertStringContainsString('Document already exists', $e->getMessage());
+        }
 
-        $updated = $database->updateDocument($collectionId, 'dev1', new Document([
-            $attrId => '1.0.0',
-        ]));
-        $this->assertSame('1.0.0', $updated->getAttribute($attrId));
-        $this->assertArrayNotHasKey($filteredStorageKey, $updated->getAttributes());
-        $userKeys = array_keys($updated->getAttributes());
-        sort($userKeys);
-        $this->assertSame([$attrId], $userKeys);
-
-        $doc = $database->getDocument($collectionId, 'dev1');
-        $this->assertSame('1.0.0', $doc->getAttribute($attrId));
-        $this->assertArrayNotHasKey($filteredStorageKey, $doc->getAttributes());
-        $userKeys = array_keys($doc->getAttributes());
-        sort($userKeys);
-        $this->assertSame([$attrId], $userKeys);
-
-        $updated = $database->updateDocument($collectionId, 'dev1', new Document([
-            $attrId => '2.0.0',
-        ]));
-        $this->assertSame('2.0.0', $updated->getAttribute($attrId));
-        $this->assertArrayNotHasKey($filteredStorageKey, $updated->getAttributes());
-        $userKeys = array_keys($updated->getAttributes());
-        sort($userKeys);
-        $this->assertSame([$attrId], $userKeys);
-
-        $doc = $database->getDocument($collectionId, 'dev1');
-        $this->assertSame('2.0.0', $doc->getAttribute($attrId));
-        $this->assertArrayNotHasKey($filteredStorageKey, $doc->getAttributes());
-        $userKeys = array_keys($doc->getAttributes());
-        sort($userKeys);
-        $this->assertSame([$attrId], $userKeys);
+        // Test 2: Unique index violation should mention "unique attributes"
+        try {
+            $database->createDocument('duplicateMessages', new Document([
+                '$id' => 'dup_msg_2',
+                '$permissions' => [
+                    Permission::read(Role::any()),
+                ],
+                'email' => 'test@example.com',
+            ]));
+            $this->fail('Expected DuplicateException for unique index violation');
+        } catch (DuplicateException $e) {
+            $this->assertStringContainsString('unique attributes', $e->getMessage());
+        }
 
-        $database->deleteCollection($collectionId);
+        $database->deleteCollection('duplicateMessages');
     }
 
-    public function testUpsertWithJSONFilters(): void
+    public function testDeleteBulkDocuments(): void
     {
-        $database = static::getDatabase();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        // Create collection with JSON filter attribute
-        $collection = ID::unique();
-        $database->createCollection($collection, permissions: [
-            Permission::read(Role::any()),
+        $database->createCollection(new Collection(id: 'bulk_delete', attributes: [
+            Attribute::string(key: 'text', size: 100, required: true),
+            Attribute::integer(key: 'integer', size: 10, required: true)
+        ], permissions: [
             Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
+            Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], documentSecurity: false));
 
-        $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, true);
-        $database->createAttribute($collection, 'metadata', Database::VAR_STRING, 4000, true, filters: ['json']);
+        $this->propagateBulkDocuments('bulk_delete');
 
-        $permissions = [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ];
+        $docs = $database->find('bulk_delete');
+        $this->assertCount(10, $docs);
 
-        // Test 1: Insertion (createDocument) with JSON filter
-        $docId1 = 'json-doc-1';
-        $initialMetadata = [
-            'version' => '1.0.0',
-            'tags' => ['php', 'database'],
-            'config' => [
-                'debug' => false,
-                'timeout' => 30
-            ]
-        ];
+        /**
+         * Test Short select query, test pagination as well, Add order to select
+         */
+        $selects = ['$sequence', '$id', '$collection', '$permissions', '$updatedAt'];
 
-        $document1 = $database->createDocument($collection, new Document([
-            '$id' => $docId1,
-            'name' => 'Initial Document',
-            'metadata' => $initialMetadata,
-            '$permissions' => $permissions,
-        ]));
+        $count = $database->deleteDocuments(
+            collection: 'bulk_delete',
+            queries: [
+                Query::select([...$selects, '$createdAt']),
+                Query::cursorAfter($docs[6]),
+                Query::greaterThan('$createdAt', '2000-01-01'),
+                Query::orderAsc('$createdAt'),
+                Query::orderAsc(),
+                Query::limit(2),
+            ],
+            batchSize: 1
+        );
 
-        $this->assertEquals($docId1, $document1->getId());
-        $this->assertEquals('Initial Document', $document1->getAttribute('name'));
-        $this->assertIsArray($document1->getAttribute('metadata'));
-        $this->assertEquals('1.0.0', $document1->getAttribute('metadata')['version']);
-        $this->assertEquals(['php', 'database'], $document1->getAttribute('metadata')['tags']);
+        $this->assertEquals(2, $count);
 
-        // Test 2: Update (updateDocument) with modified JSON filter
-        $updatedMetadata = [
-            'version' => '2.0.0',
-            'tags' => ['php', 'database', 'json'],
-            'config' => [
-                'debug' => true,
-                'timeout' => 60,
-                'cache' => true
-            ],
-            'updated' => true
-        ];
+        // TEST: Bulk Delete All Documents
+        $this->assertEquals(8, $database->deleteDocuments('bulk_delete'));
 
-        $document1->setAttribute('name', 'Updated Document');
-        $document1->setAttribute('metadata', $updatedMetadata);
+        $docs = $database->find('bulk_delete');
+        $this->assertCount(0, $docs);
 
-        $updatedDoc = $database->updateDocument($collection, $docId1, $document1);
+        // TEST: Bulk delete documents with queries.
+        $this->propagateBulkDocuments('bulk_delete');
 
-        $this->assertEquals($docId1, $updatedDoc->getId());
-        $this->assertEquals('Updated Document', $updatedDoc->getAttribute('name'));
-        $this->assertIsArray($updatedDoc->getAttribute('metadata'));
-        $this->assertEquals('2.0.0', $updatedDoc->getAttribute('metadata')['version']);
-        $this->assertEquals(['php', 'database', 'json'], $updatedDoc->getAttribute('metadata')['tags']);
-        $this->assertTrue($updatedDoc->getAttribute('metadata')['config']['debug']);
-        $this->assertTrue($updatedDoc->getAttribute('metadata')['updated']);
+        $results = [];
+        $count = $database->deleteDocuments('bulk_delete', [
+            Query::greaterThanEqual('integer', 5)
+        ], onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+        });
 
-        // Test 3: Upsert - Create new document (upsertDocument)
-        $docId2 = 'json-doc-2';
-        $newMetadata = [
-            'version' => '1.5.0',
-            'tags' => ['javascript', 'node'],
-            'config' => [
-                'debug' => false,
-                'timeout' => 45
-            ]
-        ];
+        $this->assertEquals(5, $count);
 
-        $document2 = new Document([
-            '$id' => $docId2,
-            'name' => 'New Upsert Document',
-            'metadata' => $newMetadata,
-            '$permissions' => $permissions,
-        ]);
+        foreach ($results as $document) {
+            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
+        }
 
-        $upsertedDoc = $database->upsertDocument($collection, $document2);
+        $docs = $database->find('bulk_delete');
+        $this->assertEquals(5, \count($docs));
 
-        $this->assertEquals($docId2, $upsertedDoc->getId());
-        $this->assertEquals('New Upsert Document', $upsertedDoc->getAttribute('name'));
-        $this->assertIsArray($upsertedDoc->getAttribute('metadata'));
-        $this->assertEquals('1.5.0', $upsertedDoc->getAttribute('metadata')['version']);
+        // TEST (FAIL): Can't delete documents in the past
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
 
-        // Test 4: Upsert - Update existing document (upsertDocument)
-        $document2->setAttribute('name', 'Updated Upsert Document');
-        $document2->setAttribute('metadata', [
-            'version' => '2.5.0',
-            'tags' => ['javascript', 'node', 'typescript'],
-            'config' => [
-                'debug' => true,
-                'timeout' => 90
-            ],
-            'migrated' => true
-        ]);
+        try {
+            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () {
+                return $this->getDatabase()->deleteDocuments('bulk_delete');
+            });
+            $this->fail('Failed to throw exception');
+        } catch (ConflictException $e) {
+            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
+        }
 
-        $upsertedDoc2 = $database->upsertDocument($collection, $document2);
+        // TEST (FAIL): Bulk delete all documents with invalid collection permission
+        $database->updateCollection('bulk_delete', [], false);
+        try {
+            $database->deleteDocuments('bulk_delete');
+            $this->fail('Bulk deleted documents with invalid collection permission');
+        } catch (\Utopia\Database\Exception\Authorization) {
+        }
 
-        $this->assertEquals($docId2, $upsertedDoc2->getId());
-        $this->assertEquals('Updated Upsert Document', $upsertedDoc2->getAttribute('name'));
-        $this->assertIsArray($upsertedDoc2->getAttribute('metadata'));
-        $this->assertEquals('2.5.0', $upsertedDoc2->getAttribute('metadata')['version']);
-        $this->assertEquals(['javascript', 'node', 'typescript'], $upsertedDoc2->getAttribute('metadata')['tags']);
-        $this->assertTrue($upsertedDoc2->getAttribute('metadata')['migrated']);
+        $database->updateCollection('bulk_delete', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], false);
 
-        // Test 5: Upsert - Bulk upsertDocuments (create and update)
-        $docId3 = 'json-doc-3';
-        $docId4 = 'json-doc-4';
+        $this->assertEquals(5, $database->deleteDocuments('bulk_delete'));
+        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
 
-        $bulkDocuments = [
-            new Document([
-                '$id' => $docId3,
-                'name' => 'Bulk Upsert 1',
-                'metadata' => [
-                    'version' => '3.0.0',
-                    'tags' => ['python', 'flask'],
-                    'config' => ['debug' => false]
-                ],
-                '$permissions' => $permissions,
-            ]),
-            new Document([
-                '$id' => $docId4,
-                'name' => 'Bulk Upsert 2',
-                'metadata' => [
-                    'version' => '3.1.0',
-                    'tags' => ['go', 'golang'],
-                    'config' => ['debug' => true]
-                ],
-                '$permissions' => $permissions,
-            ]),
-            // Update existing document
-            new Document([
-                '$id' => $docId1,
-                'name' => 'Bulk Updated Document',
-                'metadata' => [
-                    'version' => '3.0.0',
-                    'tags' => ['php', 'database', 'bulk'],
-                    'config' => [
-                        'debug' => false,
-                        'timeout' => 120
-                    ],
-                    'bulkUpdated' => true
-                ],
-                '$permissions' => $permissions,
-            ]),
-        ];
+        // TEST: Make sure we can't delete documents we don't have permissions for
+        $database->updateCollection('bulk_delete', [
+            Permission::create(Role::any()),
+        ], true);
+        $this->propagateBulkDocuments('bulk_delete', documentSecurity: true);
 
-        $count = $database->upsertDocuments($collection, $bulkDocuments);
-        $this->assertEquals(3, $count);
+        $this->assertEquals(0, $database->deleteDocuments('bulk_delete'));
 
-        // Verify bulk upsert results
-        $bulkDoc1 = $database->getDocument($collection, $docId3);
-        $this->assertEquals('Bulk Upsert 1', $bulkDoc1->getAttribute('name'));
-        $this->assertEquals('3.0.0', $bulkDoc1->getAttribute('metadata')['version']);
+        $documents = $this->getDatabase()->getAuthorization()->skip(function () use ($database) {
+            return $database->find('bulk_delete');
+        });
 
-        $bulkDoc2 = $database->getDocument($collection, $docId4);
-        $this->assertEquals('Bulk Upsert 2', $bulkDoc2->getAttribute('name'));
-        $this->assertEquals('3.1.0', $bulkDoc2->getAttribute('metadata')['version']);
+        $this->assertEquals(10, \count($documents));
 
-        $bulkDoc3 = $database->getDocument($collection, $docId1);
-        $this->assertEquals('Bulk Updated Document', $bulkDoc3->getAttribute('name'));
-        $this->assertEquals('3.0.0', $bulkDoc3->getAttribute('metadata')['version']);
-        $this->assertTrue($bulkDoc3->getAttribute('metadata')['bulkUpdated']);
+        $database->updateCollection('bulk_delete', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], false);
 
-        // Cleanup
-        $database->deleteCollection($collection);
+        $database->deleteDocuments('bulk_delete');
+
+        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+
+        // Teardown
+        $database->deleteCollection('bulk_delete');
     }
 
-    public function testFindRegex(): void
+    public function testDeleteBulkDocumentsQueries(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        // Skip test if regex is not supported
-        if (!$database->getAdapter()->getSupportForRegex()) {
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        // Determine regex support type
-        $supportsPCRE = $database->getAdapter()->getSupportForPCRERegex();
-        $supportsPOSIX = $database->getAdapter()->getSupportForPOSIXRegex();
+        $database->createCollection(new Collection(id: 'bulk_delete_queries', attributes: [
+            Attribute::string(key: 'text', size: 100, required: true),
+            Attribute::integer(key: 'integer', size: 10, required: true)
+        ], permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], documentSecurity: false));
 
-        // Determine word boundary pattern based on support
-        $wordBoundaryPattern = null;
-        $wordBoundaryPatternPHP = null;
-        if ($supportsPCRE) {
-            $wordBoundaryPattern = '\\b'; // PCRE uses \b
-            $wordBoundaryPatternPHP = '\\b'; // PHP preg_match uses \b
-        } elseif ($supportsPOSIX) {
-            $wordBoundaryPattern = '\\y'; // POSIX uses \y
-            $wordBoundaryPatternPHP = '\\b'; // PHP preg_match still uses \b for verification
+        // Test limit
+        $this->propagateBulkDocuments('bulk_delete_queries');
+
+        $this->assertEquals(5, $database->deleteDocuments('bulk_delete_queries', [Query::limit(5)]));
+        $this->assertEquals(5, \count($database->find('bulk_delete_queries')));
+
+        $this->assertEquals(5, $database->deleteDocuments('bulk_delete_queries', [Query::limit(5)]));
+        $this->assertEquals(0, \count($database->find('bulk_delete_queries')));
+
+        // Test Limit more than batchSize
+        $this->propagateBulkDocuments('bulk_delete_queries', Database::DELETE_BATCH_SIZE * 2);
+        $this->assertEquals(Database::DELETE_BATCH_SIZE * 2, \count($database->find('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE * 2)])));
+        $this->assertEquals(Database::DELETE_BATCH_SIZE + 2, $database->deleteDocuments('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE + 2)]));
+        $this->assertEquals(Database::DELETE_BATCH_SIZE - 2, \count($database->find('bulk_delete_queries', [Query::limit(Database::DELETE_BATCH_SIZE * 2)])));
+        $this->assertEquals(Database::DELETE_BATCH_SIZE - 2, $this->getDatabase()->deleteDocuments('bulk_delete_queries'));
+
+        // Test Offset
+        $this->propagateBulkDocuments('bulk_delete_queries', 100);
+        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries', [Query::offset(50)]));
+
+        $docs = $database->find('bulk_delete_queries', [Query::limit(100)]);
+        $this->assertEquals(50, \count($docs));
+
+        $lastDoc = \end($docs);
+        $this->assertNotEmpty($lastDoc);
+        $this->assertEquals('doc49', $lastDoc->getId());
+        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries'));
+
+        $database->deleteCollection('bulk_delete_queries');
+    }
+
+    public function testDeleteBulkDocumentsWithCallbackSupport(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
+            return;
         }
 
-        $database->createCollection('moviesRegex', permissions: [
+        $database->createCollection(new Collection(id: 'bulk_delete_with_callback', attributes: [
+            Attribute::string(key: 'text', size: 100, required: true),
+            Attribute::integer(key: 'integer', size: 10, required: true)
+        ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
+            Permission::delete(Role::any())
+        ], documentSecurity: false));
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->assertEquals(true, $database->createAttribute('moviesRegex', 'name', Database::VAR_STRING, 128, true));
-            $this->assertEquals(true, $database->createAttribute('moviesRegex', 'director', Database::VAR_STRING, 128, true));
-            $this->assertEquals(true, $database->createAttribute('moviesRegex', 'year', Database::VAR_INTEGER, 0, true));
-        }
+        $this->propagateBulkDocuments('bulk_delete_with_callback');
 
-        if ($database->getAdapter()->getSupportForTrigramIndex()) {
-            $database->createIndex('moviesRegex', 'trigram_name', Database::INDEX_TRIGRAM, ['name']);
-            $database->createIndex('moviesRegex', 'trigram_director', Database::INDEX_TRIGRAM, ['director']);
-        }
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertCount(10, $docs);
 
-        // Create test documents
-        $database->createDocuments('moviesRegex', [
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
+        /**
+         * Test Short select query, test pagination as well, Add order to select
+         */
+        $selects = ['$sequence', '$id', '$collection', '$permissions', '$updatedAt'];
+
+        try {
+            // a non existent document to test the error thrown
+            $database->deleteDocuments(
+                collection: 'bulk_delete_with_callback',
+                queries: [
+                    Query::select([...$selects, '$createdAt']),
+                    Query::lessThan('$createdAt', '1800-01-01'),
+                    Query::orderAsc('$createdAt'),
+                    Query::orderAsc(),
+                    Query::limit(1),
                 ],
-                'name' => 'Frozen',
-                'director' => 'Chris Buck & Jennifer Lee',
-                'year' => 2013,
-            ]),
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-                'name' => 'Frozen II',
-                'director' => 'Chris Buck & Jennifer Lee',
-                'year' => 2019,
-            ]),
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-                'name' => 'Captain America: The First Avenger',
-                'director' => 'Joe Johnston',
-                'year' => 2011,
-            ]),
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-                'name' => 'Captain Marvel',
-                'director' => 'Anna Boden & Ryan Fleck',
-                'year' => 2019,
-            ]),
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-                'name' => 'Work in Progress',
-                'director' => 'TBD',
-                'year' => 2025,
-            ]),
-            new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any()),
-                ],
-                'name' => 'Work in Progress 2',
-                'director' => 'TBD',
-                'year' => 2026,
-            ]),
-        ]);
-
-        // Helper function to verify regex query completeness
-        $verifyRegexQuery = function (string $attribute, string $regexPattern, array $queryResults) use ($database) {
-            // Convert database regex pattern to PHP regex format.
-            // POSIX-style word boundary (\y) is not supported by PHP PCRE, so map it to \b.
-            $normalizedPattern = str_replace('\y', '\b', $regexPattern);
-            $phpPattern = '/' . str_replace('/', '\/', $normalizedPattern) . '/';
+                batchSize: 1,
+                onNext: function () {
+                    throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
+                }
+            );
+        } catch (Exception $e) {
+            $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
+        }
 
-            // Get all documents to manually verify
-            $allDocuments = $database->find('moviesRegex');
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertCount(10, $docs);
 
-            // Manually filter documents that match the pattern
-            $expectedMatches = [];
-            foreach ($allDocuments as $doc) {
-                $value = $doc->getAttribute($attribute);
-                if (preg_match($phpPattern, $value)) {
-                    $expectedMatches[] = $doc->getId();
-                }
+        $count = $database->deleteDocuments(
+            collection: 'bulk_delete_with_callback',
+            queries: [
+                Query::select([...$selects, '$createdAt']),
+                Query::cursorAfter($docs[6]),
+                Query::greaterThan('$createdAt', '2000-01-01'),
+                Query::orderAsc('$createdAt'),
+                Query::orderAsc(),
+                Query::limit(2),
+            ],
+            batchSize: 1,
+            onNext: function () {
+                // simulating error throwing but should not stop deletion
+                throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
+            },
+            onError:function ($e) {
+                $this->assertInstanceOf(Exception::class, $e);
+                $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
             }
+        );
 
-            // Get IDs from query results
-            $actualMatches = array_map(fn ($doc) => $doc->getId(), $queryResults);
+        $this->assertEquals(2, $count);
 
-            // Verify no extra documents are returned
-            foreach ($queryResults as $doc) {
-                $value = $doc->getAttribute($attribute);
-                $this->assertTrue(
-                    (bool) preg_match($phpPattern, $value),
-                    "Document '{$doc->getId()}' with {$attribute}='{$value}' should match pattern '{$regexPattern}'"
-                );
-            }
+        // TEST: Bulk Delete All Documents without passing callbacks
+        $this->assertEquals(8, $database->deleteDocuments('bulk_delete_with_callback'));
 
-            // Verify all expected documents are returned (no missing)
-            sort($expectedMatches);
-            sort($actualMatches);
-            $this->assertEquals(
-                $expectedMatches,
-                $actualMatches,
-                "Query should return exactly the documents matching pattern '{$regexPattern}' on attribute '{$attribute}'"
-            );
-        };
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertCount(0, $docs);
 
-        // Test basic regex pattern - match movies starting with 'Captain'
-        // Note: Pattern format may vary by adapter (MongoDB uses regex strings, SQL uses REGEXP)
-        $pattern = '/^Captain/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '^Captain'),
-        ]);
+        // TEST: Bulk delete documents with queries with callbacks
+        $this->propagateBulkDocuments('bulk_delete_with_callback');
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '^Captain', $documents);
+        $results = [];
+        $count = $database->deleteDocuments('bulk_delete_with_callback', [
+            Query::greaterThanEqual('integer', 5)
+        ], onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+            throw new Exception("Error thrown to test that deletion doesn't stop and error is caught");
+        }, onError:function ($e) {
+            $this->assertEquals("Error thrown to test that deletion doesn't stop and error is caught", $e->getMessage());
+        });
 
-        // Verify expected documents are included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Captain America: The First Avenger', $names));
-        $this->assertTrue(in_array('Captain Marvel', $names));
+        $this->assertEquals(5, $count);
 
-        // Test regex pattern - match movies containing 'Frozen'
-        $pattern = '/Frozen/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'Frozen'),
-        ]);
+        foreach ($results as $document) {
+            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
+        }
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', 'Frozen', $documents);
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertEquals(5, \count($docs));
 
-        // Test regex pattern - match exact title 'Frozen'
-        $exactFrozenDocuments = $database->find('moviesRegex', [
-            Query::regex('name', '^Frozen$'),
-        ]);
-        $verifyRegexQuery('name', '^Frozen$', $exactFrozenDocuments);
-        $this->assertCount(1, $exactFrozenDocuments, 'Exact ^Frozen$ regex should return only one document');
-        // Verify expected documents are included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Frozen', $names));
-        $this->assertTrue(in_array('Frozen II', $names));
+        // Teardown
+        $database->deleteCollection('bulk_delete_with_callback');
+    }
 
-        // Test regex pattern - match movies ending with 'Marvel'
-        $pattern = '/Marvel$/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'Marvel$'),
-        ]);
+    public function testUpdateDocumentsQueries(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', 'Marvel$', $documents);
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $this->assertEquals(1, count($documents)); // Only Captain Marvel
-        $this->assertEquals('Captain Marvel', $documents[0]->getAttribute('name'));
+        $collection = 'testUpdateDocumentsQueries';
 
-        // Test regex pattern - match movies with 'Work' in the name
-        $pattern = '/.*Work.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*Work.*'),
-        ]);
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'text', size: 64, required: true),
+            Attribute::integer(key: 'integer', size: 64, required: true),
+        ], permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any())
+        ]));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '.*Work.*', $documents);
+        // Test limit
+        $this->propagateBulkDocuments($collection, 100);
 
-        // Verify expected documents are included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Work in Progress', $names));
-        $this->assertTrue(in_array('Work in Progress 2', $names));
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'text' => 'text📝 updated',
+        ]), [Query::limit(10)]));
 
-        // Test regex pattern - match movies with 'Buck' in director
-        $pattern = '/.*Buck.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('director', '.*Buck.*'),
-        ]);
+        $this->assertEquals(10, \count($database->find($collection, [Query::equal('text', ['text📝 updated'])])));
+        $this->assertEquals(100, $database->deleteDocuments($collection));
+        $this->assertEquals(0, \count($database->find($collection)));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('director', '.*Buck.*', $documents);
+        // Test Offset
+        $this->propagateBulkDocuments($collection, 100);
+        $this->assertEquals(50, $database->updateDocuments($collection, new Document([
+            'text' => 'text📝 updated',
+        ]), [
+            Query::offset(50),
+        ]));
 
-        // Verify expected documents are included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Frozen', $names));
-        $this->assertTrue(in_array('Frozen II', $names));
+        $docs = $database->find($collection, [Query::equal('text', ['text📝 updated']), Query::limit(100)]);
+        $this->assertCount(50, $docs);
 
-        // Test regex with case pattern - adapters may be case-sensitive or case-insensitive
-        // MySQL/MariaDB REGEXP is case-insensitive by default, MongoDB is case-sensitive
-        $patternCaseSensitive = '/captain/';
-        $patternCaseInsensitive = '/captain/i';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'captain'), // lowercase
-        ]);
+        $lastDoc = end($docs);
+        $this->assertNotEmpty($lastDoc);
+        $this->assertEquals('doc99', $lastDoc->getId());
 
-        // Verify all returned documents match the pattern (case-insensitive check for verification)
-        foreach ($documents as $doc) {
-            $name = $doc->getAttribute('name');
-            // Verify that returned documents contain 'captain' (case-insensitive check)
-            $this->assertTrue(
-                (bool) preg_match($patternCaseInsensitive, $name),
-                "Document '{$name}' should match pattern 'captain' (case-insensitive check)"
-            );
-        }
+        $this->assertEquals(100, $database->deleteDocuments($collection));
+    }
 
-        // Verify completeness: Check what the database actually returns
-        // Some adapters (MongoDB) are case-sensitive, others (MySQL/MariaDB) are case-insensitive
-        // We'll determine expected matches based on case-sensitive matching (pure regex behavior)
-        // If the adapter is case-insensitive, it will return more documents, which is fine
-        $allDocuments = $database->find('moviesRegex');
-        $expectedMatchesCaseSensitive = [];
-        $expectedMatchesCaseInsensitive = [];
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            if (preg_match($patternCaseSensitive, $name)) {
-                $expectedMatchesCaseSensitive[] = $doc->getId();
-            }
-            if (preg_match($patternCaseInsensitive, $name)) {
-                $expectedMatchesCaseInsensitive[] = $doc->getId();
-            }
-        }
-
-        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-        sort($actualMatches);
-
-        // The database might be case-sensitive (MongoDB) or case-insensitive (MySQL/MariaDB)
-        // Check which one matches the actual results
-        sort($expectedMatchesCaseSensitive);
-        sort($expectedMatchesCaseInsensitive);
-
-        // Verify that actual results match either case-sensitive or case-insensitive expectations
-        $matchesCaseSensitive = ($expectedMatchesCaseSensitive === $actualMatches);
-        $matchesCaseInsensitive = ($expectedMatchesCaseInsensitive === $actualMatches);
-
-        $this->assertTrue(
-            $matchesCaseSensitive || $matchesCaseInsensitive,
-            "Query results should match either case-sensitive (" . count($expectedMatchesCaseSensitive) . " docs) or case-insensitive (" . count($expectedMatchesCaseInsensitive) . " docs) expectations. Got " . count($actualMatches) . " documents."
-        );
-
-        // Test regex with case-insensitive pattern (if adapter supports it via flags)
-        // Test with uppercase to verify case sensitivity
-        $pattern = '/Captain/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'Captain'), // uppercase
-        ]);
-
-        // Verify all returned documents match the pattern
-        foreach ($documents as $doc) {
-            $name = $doc->getAttribute('name');
-            $this->assertTrue(
-                (bool) preg_match($pattern, $name),
-                "Document '{$name}' should match pattern 'Captain'"
-            );
-        }
-
-        // Verify completeness
-        $allDocuments = $database->find('moviesRegex');
-        $expectedMatches = [];
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            if (preg_match($pattern, $name)) {
-                $expectedMatches[] = $doc->getId();
-            }
-        }
-        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-        sort($expectedMatches);
-        sort($actualMatches);
-        $this->assertEquals(
-            $expectedMatches,
-            $actualMatches,
-            "Query should return exactly the documents matching pattern 'Captain'"
-        );
-
-        // Test regex combined with other queries
-        $pattern = '/^Captain/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '^Captain'),
-            Query::greaterThan('year', 2010),
-        ]);
-
-        // Verify all returned documents match both conditions
-        foreach ($documents as $doc) {
-            $name = $doc->getAttribute('name');
-            $year = $doc->getAttribute('year');
-            $this->assertTrue(
-                (bool) preg_match($pattern, $name),
-                "Document '{$name}' should match pattern '{$pattern}'"
-            );
-            $this->assertGreaterThan(2010, $year, "Document '{$name}' should have year > 2010");
-        }
+    public function testEmptyOperatorValues(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+        $this->initDocumentsFixture();
 
-        // Verify completeness: manually check all documents that match both conditions
-        $allDocuments = $database->find('moviesRegex');
-        $expectedMatches = [];
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            $year = $doc->getAttribute('year');
-            if (preg_match($pattern, $name) && $year > 2010) {
-                $expectedMatches[] = $doc->getId();
-            }
+        try {
+            $database->findOne($this->getDocumentsCollection(), [
+                Query::equal('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertEquals('Invalid query: Equal queries require at least one value.', $e->getMessage());
         }
-        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-        sort($expectedMatches);
-        sort($actualMatches);
-        $this->assertEquals(
-            $expectedMatches,
-            $actualMatches,
-            "Query should return exactly the documents matching both regex '^Captain' and year > 2010"
-        );
-
-        // Test regex with limit
-        $pattern = '/.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*'), // Match all
-            Query::limit(3),
-        ]);
-
-        $this->assertEquals(3, count($documents));
 
-        // Verify all returned documents match the pattern (should match all)
-        foreach ($documents as $doc) {
-            $name = $doc->getAttribute('name');
-            $this->assertTrue(
-                (bool) preg_match($pattern, $name),
-                "Document '{$name}' should match pattern '{$pattern}'"
-            );
+        try {
+            $database->findOne($this->getDocumentsCollection(), [
+                Query::contains('string', []),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertEquals('Invalid query: Contains queries require at least one value.', $e->getMessage());
         }
+    }
 
-        // Note: With limit, we can't verify completeness, but we can verify all returned match
-
-        // Test regex with non-matching pattern
-        $pattern = '/^NonExistentPattern$/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '^NonExistentPattern$'),
-        ]);
-
-        $this->assertEquals(0, count($documents));
+    public function testSingleDocumentDateOperations(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+        $collection = 'normal_date_operations';
+        $database->createCollection(new Collection(id: $collection));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128)));
 
-        // Verify no documents match (double-check by getting all and filtering)
-        $allDocuments = $database->find('moviesRegex');
-        $matchingCount = 0;
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            if (preg_match($pattern, $name)) {
-                $matchingCount++;
-            }
-        }
-        $this->assertEquals(0, $matchingCount, "No documents should match pattern '{$pattern}'");
+        $database->setPreserveDates(true);
 
-        // Verify completeness: no documents should be returned
-        $this->assertEquals([], array_map(fn ($doc) => $doc->getId(), $documents));
+        $createDate = '2000-01-01T10:00:00.000+00:00';
+        $updateDate = '2000-02-01T15:30:00.000+00:00';
+        $date1 = '2000-01-01T10:00:00.000+00:00';
+        $date2 = '2000-02-01T15:30:00.000+00:00';
+        $date3 = '2000-03-01T20:45:00.000+00:00';
+        // Test 1: Create with custom createdAt, then update with custom updatedAt
+        $doc = $database->createDocument($collection, new Document([
+            '$id' => 'doc1',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'initial',
+            '$createdAt' => $createDate
+        ]));
 
-        // Test regex with special characters (should be escaped or handled properly)
-        $pattern = '/.*:.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*:.*'), // Match movies with colon
-        ]);
+        $this->assertEquals($createDate, $doc->getAttribute('$createdAt'));
+        $this->assertNotEquals($createDate, $doc->getAttribute('$updatedAt'));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '.*:.*', $documents);
+        // Update with custom updatedAt
+        $doc->setAttribute('string', 'updated');
+        $doc->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc = $database->updateDocument($collection, 'doc1', $doc);
 
-        // Verify expected document is included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Captain America: The First Avenger', $names));
+        $this->assertEquals($createDate, $updatedDoc->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $updatedDoc->getAttribute('$updatedAt'));
 
-        // ReDOS safety: ensure pathological patterns respond quickly and do not hang
-        $catastrophicPattern = '(a+)+$';
-        $start = microtime(true);
-        $redosDocs = $database->find('moviesRegex', [
-            Query::regex('name', $catastrophicPattern),
-        ]);
-        $elapsed = microtime(true) - $start;
-        $this->assertLessThan(1.0, $elapsed, 'Regex evaluation should not be slow or vulnerable to ReDOS');
-        $verifyRegexQuery('name', $catastrophicPattern, $redosDocs);
-        $this->assertCount(0, $redosDocs, 'Pathological regex should not match any movie titles');
+        // Test 2: Create with both custom dates
+        $doc2 = $database->createDocument($collection, new Document([
+            '$id' => 'doc2',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'both_dates',
+            '$createdAt' => $createDate,
+            '$updatedAt' => $updateDate
+        ]));
 
-        // Test regex search pattern - match movies with word boundaries
-        // Only test if word boundaries are supported (PCRE or POSIX)
-        if ($wordBoundaryPattern !== null) {
-            $dbPattern = $wordBoundaryPattern . 'Work' . $wordBoundaryPattern;
-            $phpPattern = '/' . $wordBoundaryPatternPHP . 'Work' . $wordBoundaryPatternPHP . '/';
-            $documents = $database->find('moviesRegex', [
-                Query::regex('name', $dbPattern),
-            ]);
+        $this->assertEquals($createDate, $doc2->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $doc2->getAttribute('$updatedAt'));
 
-            // Verify all returned documents match the pattern
-            foreach ($documents as $doc) {
-                $name = $doc->getAttribute('name');
-                $this->assertTrue(
-                    (bool) preg_match($phpPattern, $name),
-                    "Document '{$name}' should match pattern '{$dbPattern}'"
-                );
-            }
+        // Test 3: Create without dates, then update with custom dates
+        $doc3 = $database->createDocument($collection, new Document([
+            '$id' => 'doc3',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'no_dates'
+        ]));
 
-            // Verify completeness: manually check all documents
-            $allDocuments = $database->find('moviesRegex');
-            $expectedMatches = [];
-            foreach ($allDocuments as $doc) {
-                $name = $doc->getAttribute('name');
-                if (preg_match($phpPattern, $name)) {
-                    $expectedMatches[] = $doc->getId();
-                }
-            }
-            $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-            sort($expectedMatches);
-            sort($actualMatches);
-            $this->assertEquals(
-                $expectedMatches,
-                $actualMatches,
-                "Query should return exactly the documents matching pattern '{$dbPattern}'"
-            );
-        }
+        $doc3->setAttribute('string', 'updated_no_dates');
+        $doc3->setAttribute('$createdAt', $createDate);
+        $doc3->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc3 = $database->updateDocument($collection, 'doc3', $doc3);
 
-        // Test regex search with multiple patterns - match movies containing 'Captain' or 'Frozen'
-        $pattern1 = '/Captain/';
-        $pattern2 = '/Frozen/';
-        $documents = $database->find('moviesRegex', [
-            Query::or([
-                Query::regex('name', 'Captain'),
-                Query::regex('name', 'Frozen'),
-            ]),
-        ]);
+        $this->assertEquals($createDate, $updatedDoc3->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $updatedDoc3->getAttribute('$updatedAt'));
 
-        // Verify all returned documents match at least one pattern
-        foreach ($documents as $doc) {
-            $name = $doc->getAttribute('name');
-            $matchesPattern1 = (bool) preg_match($pattern1, $name);
-            $matchesPattern2 = (bool) preg_match($pattern2, $name);
-            $this->assertTrue(
-                $matchesPattern1 || $matchesPattern2,
-                "Document '{$name}' should match either pattern 'Captain' or 'Frozen'"
-            );
-        }
-
-        // Verify completeness: manually check all documents
-        $allDocuments = $database->find('moviesRegex');
-        $expectedMatches = [];
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            if (preg_match($pattern1, $name) || preg_match($pattern2, $name)) {
-                $expectedMatches[] = $doc->getId();
-            }
-        }
-        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-        sort($expectedMatches);
-        sort($actualMatches);
-        $this->assertEquals(
-            $expectedMatches,
-            $actualMatches,
-            "Query should return exactly the documents matching pattern 'Captain' OR 'Frozen'"
-        );
-        $database->deleteCollection('moviesRegex');
-    }
-    public function testRegexInjection(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Skip test if regex is not supported
-        if (!$database->getAdapter()->getSupportForRegex()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = 'injectionTest';
-        $database->createCollection($collectionName, permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
-
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'text', Database::VAR_STRING, 1000, true));
-        }
-
-        // Create test documents - one that should match, one that shouldn't
-        $database->createDocument($collectionName, new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'text' => 'target',
-        ]));
-
-        $database->createDocument($collectionName, new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'text' => 'other',
-        ]));
-
-        // SQL injection attempts - these should NOT return the "other" document
-        $sqlInjectionPatterns = [
-            "target') OR '1'='1",           // SQL injection attempt
-            "target' OR 1=1--",            // SQL injection with comment
-            "target' OR 'x'='x",           // SQL injection attempt
-            "target' UNION SELECT *--",     // SQL UNION injection
-        ];
-
-        // MongoDB injection attempts - these should NOT return the "other" document
-        $mongoInjectionPatterns = [
-            'target" || "1"=="1',          // MongoDB injection attempt
-            'target" || true',              // MongoDB boolean injection
-            'target"} || {"text": "other"}', // MongoDB operator injection
-        ];
-
-        $allInjectionPatterns = array_merge($sqlInjectionPatterns, $mongoInjectionPatterns);
-
-        foreach ($allInjectionPatterns as $pattern) {
-            try {
-                $results = $database->find($collectionName, [
-                    Query::regex('text', $pattern),
-                ]);
-
-                // Critical check: if injection succeeded, we might get the "other" document
-                // which should NOT match a pattern starting with "target"
-                $foundOther = false;
-                foreach ($results as $doc) {
-                    $text = $doc->getAttribute('text');
-                    if ($text === 'other') {
-                        $foundOther = true;
-
-                        // Verify that "other" doesn't actually match the pattern as a regex
-                        $matches = @preg_match('/' . str_replace('/', '\/', $pattern) . '/', $text);
-                        if ($matches === 0 || $matches === false) {
-                            // "other" doesn't match the pattern but was returned
-                            // This indicates potential injection vulnerability
-                            $this->fail(
-                                "Potential injection detected: Pattern '{$pattern}' returned document 'other' " .
-                                "which doesn't match the pattern. This suggests SQL/MongoDB injection may have succeeded."
-                            );
-                        }
-                    }
-                }
-
-                // Additional verification: check that all returned documents actually match the pattern
-                foreach ($results as $doc) {
-                    $text = $doc->getAttribute('text');
-                    $matches = @preg_match('/' . str_replace('/', '\/', $pattern) . '/', $text);
-
-                    // If pattern is invalid, skip validation
-                    if ($matches === false) {
-                        continue;
-                    }
-
-                    // If document doesn't match but was returned, it's suspicious
-                    if ($matches === 0) {
-                        $this->fail(
-                            "Potential injection: Document '{$text}' was returned for pattern '{$pattern}' " .
-                            "but doesn't match the regex pattern."
-                        );
-                    }
-                }
-
-            } catch (\Exception $e) {
-                // Exceptions are acceptable - they indicate the injection was blocked or caused an error
-                // This is actually good - it means the system rejected the malicious pattern
-                $this->assertInstanceOf(\Exception::class, $e);
-            }
-        }
-
-        // Test that legitimate regex patterns still work correctly
-        $legitimatePatterns = [
-            'target',      // Should match "target"
-            '^target',     // Should match "target" (anchored)
-            'other',       // Should match "other"
-        ];
-
-        foreach ($legitimatePatterns as $pattern) {
-            try {
-                $results = $database->find($collectionName, [
-                    Query::regex('text', $pattern),
-                ]);
-
-                $this->assertIsArray($results);
-
-                // Verify each result actually matches
-                foreach ($results as $doc) {
-                    $text = $doc->getAttribute('text');
-                    $matches = @preg_match('/' . str_replace('/', '\/', $pattern) . '/', $text);
-                    if ($matches !== false) {
-                        $this->assertEquals(
-                            1,
-                            $matches,
-                            "Document '{$text}' should match pattern '{$pattern}'"
-                        );
-                    }
-                }
-            } catch (\Exception $e) {
-                $this->fail("Legitimate pattern '{$pattern}' should not throw exception: " . $e->getMessage());
-            }
-        }
-
-        // Cleanup
-        $database->deleteCollection($collectionName);
-    }
-
-    /**
-     * Test ReDoS (Regular Expression Denial of Service) with timeout protection
-     * This test verifies that ReDoS patterns either timeout properly or complete quickly,
-     * preventing denial of service attacks.
-     */
-    //    public function testRegexRedos(): void
-    //    {
-    //        /** @var Database $database */
-    //        $database = static::getDatabase();
-    //
-    //        // Skip test if regex is not supported
-    //        if (!$database->getAdapter()->getSupportForRegex()) {
-    //            $this->expectNotToPerformAssertions();
-    //            return;
-    //        }
-    //
-    //        $collectionName = 'redosTimeoutTest';
-    //        $database->createCollection($collectionName, permissions: [
-    //            Permission::create(Role::any()),
-    //            Permission::read(Role::any()),
-    //            Permission::update(Role::any()),
-    //            Permission::delete(Role::any()),
-    //        ]);
-    //
-    //        if ($database->getAdapter()->getSupportForAttributes()) {
-    //            $this->assertEquals(true, $database->createAttribute($collectionName, 'text', Database::VAR_STRING, 1000, true));
-    //        }
-    //
-    //        // Create documents with strings designed to trigger ReDoS
-    //        // These strings have many 'a's but end with 'c' instead of 'b'
-    //        // This causes catastrophic backtracking with patterns like (a+)+b
-    //        $redosStrings = [];
-    //        for ($i = 15; $i <= 35; $i += 5) {
-    //            $redosStrings[] = str_repeat('a', $i) . 'c';
-    //        }
-    //
-    //        // Also add some normal strings
-    //        $normalStrings = [
-    //            'normal text',
-    //            'another string',
-    //            'test123',
-    //            'valid data',
-    //        ];
-    //
-    //        $documents = [];
-    //        foreach ($redosStrings as $text) {
-    //            $documents[] = new Document([
-    //                '$permissions' => [
-    //                    Permission::read(Role::any()),
-    //                    Permission::create(Role::any()),
-    //                    Permission::update(Role::any()),
-    //                    Permission::delete(Role::any()),
-    //                ],
-    //                'text' => $text,
-    //            ]);
-    //        }
-    //
-    //        foreach ($normalStrings as $text) {
-    //            $documents[] = new Document([
-    //                '$permissions' => [
-    //                    Permission::read(Role::any()),
-    //                    Permission::create(Role::any()),
-    //                    Permission::update(Role::any()),
-    //                    Permission::delete(Role::any()),
-    //                ],
-    //                'text' => $text,
-    //            ]);
-    //        }
-    //
-    //        $database->createDocuments($collectionName, $documents);
-    //
-    //        // ReDoS patterns that cause exponential backtracking
-    //        $redosPatterns = [
-    //            '(a+)+b',      // Classic ReDoS: nested quantifiers
-    //            '(a|a)*b',     // Alternation with quantifier
-    //            '(a+)+$',      // Anchored pattern
-    //            '(a*)*b',      // Nested star quantifiers
-    //            '(a+)+b+',     // Multiple nested quantifiers
-    //            '(.+)+b',      // Generic nested quantifiers
-    //            '(.*)+b',      // Generic nested quantifiers
-    //        ];
-    //
-    //        $supportsTimeout = $database->getAdapter()->getSupportForTimeouts();
-    //
-    //        if ($supportsTimeout) {
-    //            $database->setTimeout(2000);
-    //        }
-    //
-    //        foreach ($redosPatterns as $pattern) {
-    //            $startTime = microtime(true);
-    //
-    //            try {
-    //                $results = $database->find($collectionName, [
-    //                    Query::regex('text', $pattern),
-    //                ]);
-    //                $elapsed = microtime(true) - $startTime;
-    //                // If timeout is supported, the query should either:
-    //                // 1. Complete quickly (< 3 seconds) if ReDoS is mitigated
-    //                // 2. Throw TimeoutException if it takes too long
-    //                if ($supportsTimeout) {
-    //                    // If we got here without timeout, it should have completed quickly
-    //                    $this->assertLessThan(
-    //                        3.0,
-    //                        $elapsed,
-    //                        "Regex pattern '{$pattern}' should complete quickly or timeout. Took {$elapsed}s"
-    //                    );
-    //                } else {
-    //                    // Without timeout support, we just check it doesn't hang forever
-    //                    // Set a reasonable upper bound (15 seconds) for systems without timeout
-    //                    $this->assertLessThan(
-    //                        15.0,
-    //                        $elapsed,
-    //                        "Regex pattern '{$pattern}' should not cause excessive delay. Took {$elapsed}s"
-    //                    );
-    //                }
-    //
-    //                // Verify results: none of our ReDoS strings should match these patterns
-    //                // (they all end with 'c', not 'b')
-    //                foreach ($results as $doc) {
-    //                    $text = $doc->getAttribute('text');
-    //                    // If it matched, verify it's actually a valid match
-    //                    $matches = @preg_match('/' . str_replace('/', '\/', $pattern) . '/', $text);
-    //                    if ($matches !== false) {
-    //                        $this->assertEquals(
-    //                            1,
-    //                            $matches,
-    //                            "Document with text '{$text}' should actually match pattern '{$pattern}'"
-    //                        );
-    //                    }
-    //                }
-    //
-    //            } catch (TimeoutException $e) {
-    //                // Timeout is expected for ReDoS patterns if not properly mitigated
-    //                $elapsed = microtime(true) - $startTime;
-    //                $this->assertInstanceOf(
-    //                    TimeoutException::class,
-    //                    $e,
-    //                    "Regex pattern '{$pattern}' should timeout if it causes ReDoS. Elapsed: {$elapsed}s"
-    //                );
-    //
-    //                // Timeout should happen within reasonable time (not immediately, but not too late)
-    //                // Fast timeouts are actually good - they mean the system is protecting itself quickly
-    //                $this->assertGreaterThan(
-    //                    0.05,
-    //                    $elapsed,
-    //                    "Timeout should occur after some minimal processing time"
-    //                );
-    //
-    //                // Timeout should happen before the timeout limit (with some buffer)
-    //                if ($supportsTimeout) {
-    //                    $this->assertLessThan(
-    //                        5.0,
-    //                        $elapsed,
-    //                        "Timeout should occur within reasonable time (before 5 seconds)"
-    //                    );
-    //                }
-    //
-    //            } catch (\Exception $e) {
-    //                // Check if this is a query interruption/timeout from MySQL (error 1317)
-    //                // MySQL sometimes throws "Query execution was interrupted" instead of TimeoutException
-    //                $message = $e->getMessage();
-    //                $isQueryInterrupted = false;
-    //
-    //                // Check message for interruption keywords
-    //                if (strpos($message, 'Query execution was interrupted') !== false ||
-    //                    strpos($message, 'interrupted') !== false) {
-    //                    $isQueryInterrupted = true;
-    //                }
-    //
-    //                // Check if it's a PDOException with error code 1317
-    //                if ($e instanceof PDOException) {
-    //                    $errorInfo = $e->errorInfo ?? [];
-    //                    // Error 1317 is "Query execution was interrupted"
-    //                    if (isset($errorInfo[1]) && $errorInfo[1] === 1317) {
-    //                        $isQueryInterrupted = true;
-    //                    }
-    //                    // Also check SQLSTATE 70100
-    //                    if ($e->getCode() === '70100') {
-    //                        $isQueryInterrupted = true;
-    //                    }
-    //                }
-    //
-    //                if ($isQueryInterrupted) {
-    //                    // This is effectively a timeout - MySQL interrupted the query
-    //                    $elapsed = microtime(true) - $startTime;
-    //                    $this->assertGreaterThan(
-    //                        0.05,
-    //                        $elapsed,
-    //                        "Query interruption should occur after some minimal processing time"
-    //                    );
-    //                    // This is acceptable - the query was interrupted due to timeout
-    //                    continue;
-    //                }
-    //
-    //                // Other exceptions are unexpected
-    //                $this->fail("Unexpected exception for pattern '{$pattern}': " . get_class($e) . " - " . $e->getMessage());
-    //            }
-    //        }
-    //
-    //        // Test with a pattern that should match quickly (not ReDoS)
-    //        $safePattern = 'normal';
-    //        $startTime = microtime(true);
-    //        $results = $database->find($collectionName, [
-    //            Query::regex('text', $safePattern),
-    //        ]);
-    //        $elapsed = microtime(true) - $startTime;
-    //
-    //        // Safe patterns should complete very quickly
-    //        $this->assertLessThan(1.0, $elapsed, 'Safe regex pattern should complete quickly');
-    //        $this->assertGreaterThan(0, count($results), 'Safe pattern should match some documents');
-    //
-    //        // Verify safe pattern results are correct
-    //        foreach ($results as $doc) {
-    //            $text = $doc->getAttribute('text');
-    //            $this->assertStringContainsString('normal', $text, "Document '{$text}' should contain 'normal'");
-    //        }
-    //
-    //        // Cleanup
-    //        if ($supportsTimeout) {
-    //            $database->clearTimeout();
-    //        }
-    //        $database->deleteCollection($collectionName);
-    //    }
+        // Test 4: Update only createdAt
+        $doc4 = $database->createDocument($collection, new Document([
+            '$id' => 'doc4',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'initial'
+        ]));
 
-    public function testCreateDocumentsIgnoreDuplicates(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $originalCreatedAt4 = $doc4->getAttribute('$createdAt');
+        $originalUpdatedAt4 = $doc4->getAttribute('$updatedAt');
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'name', Database::VAR_STRING, 128, true);
+        sleep(1); // Ensure $updatedAt differs when adapter timestamp precision is seconds
 
-        // Insert initial documents
-        $database->createDocuments(__FUNCTION__, [
-            new Document([
-                '$id' => 'doc1',
-                'name' => 'Original A',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
-            ]),
-            new Document([
-                '$id' => 'doc2',
-                'name' => 'Original B',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
-            ]),
-        ]);
+        $doc4->setAttribute('$updatedAt', null);
+        $doc4->setAttribute('$createdAt', null);
+        $updatedDoc4 = $database->updateDocument($collection, 'doc4', document: $doc4);
 
-        // Without ignore, duplicates should throw
-        try {
-            $database->createDocuments(__FUNCTION__, [
-                new Document([
-                    '$id' => 'doc1',
-                    'name' => 'Duplicate A',
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::create(Role::any()),
-                    ],
-                ]),
-            ]);
-            $this->fail('Expected DuplicateException');
-        } catch (DuplicateException $e) {
-            $this->assertNotEmpty($e->getMessage());
-        }
+        $this->assertEquals($originalCreatedAt4, $updatedDoc4->getAttribute('$createdAt'));
+        $this->assertNotEquals($originalUpdatedAt4, $updatedDoc4->getAttribute('$updatedAt'));
 
-        // With skipDuplicates, duplicates should be silently skipped
-        $emittedIds = [];
-        $collection = __FUNCTION__;
-        $count = $database->skipDuplicates(function () use ($database, $collection, &$emittedIds) {
-            return $database->createDocuments($collection, [
-                new Document([
-                    '$id' => 'doc1',
-                    'name' => 'Duplicate A',
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::create(Role::any()),
-                    ],
-                ]),
-                new Document([
-                    '$id' => 'doc3',
-                    'name' => 'New C',
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::create(Role::any()),
-                    ],
-                ]),
-            ], onNext: function (Document $doc) use (&$emittedIds) {
-                $emittedIds[] = $doc->getId();
-            });
-        });
+        // Test 5: Update only updatedAt
+        $updatedDoc4->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc4->setAttribute('$createdAt', $createDate);
+        $finalDoc4 = $database->updateDocument($collection, 'doc4', $updatedDoc4);
+
+        $this->assertEquals($createDate, $finalDoc4->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $finalDoc4->getAttribute('$updatedAt'));
+
+        // Test 6: Create with updatedAt, update with createdAt
+        $doc5 = $database->createDocument($collection, new Document([
+            '$id' => 'doc5',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'doc5',
+            '$updatedAt' => $date2
+        ]));
+
+        $this->assertNotEquals($date2, $doc5->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $doc5->getAttribute('$updatedAt'));
+
+        $doc5->setAttribute('string', 'doc5_updated');
+        $doc5->setAttribute('$createdAt', $date1);
+        $updatedDoc5 = $database->updateDocument($collection, 'doc5', $doc5);
+
+        $this->assertEquals($date1, $updatedDoc5->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $updatedDoc5->getAttribute('$updatedAt'));
+
+        // Test 7: Create with both dates, update with different dates
+        $doc6 = $database->createDocument($collection, new Document([
+            '$id' => 'doc6',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'doc6',
+            '$createdAt' => $date1,
+            '$updatedAt' => $date2
+        ]));
+
+        $this->assertEquals($date1, $doc6->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $doc6->getAttribute('$updatedAt'));
+
+        $doc6->setAttribute('string', 'doc6_updated');
+        $doc6->setAttribute('$createdAt', $date3);
+        $doc6->setAttribute('$updatedAt', $date3);
+        $updatedDoc6 = $database->updateDocument($collection, 'doc6', $doc6);
+
+        $this->assertEquals($date3, $updatedDoc6->getAttribute('$createdAt'));
+        $this->assertEquals($date3, $updatedDoc6->getAttribute('$updatedAt'));
+
+        // Test 8: Preserve dates disabled
+        $database->setPreserveDates(false);
+
+        $customDate = '2000-01-01T10:00:00.000+00:00';
+
+        $doc7 = $database->createDocument($collection, new Document([
+            '$id' => 'doc7',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'doc7',
+            '$createdAt' => $customDate,
+            '$updatedAt' => $customDate
+        ]));
+
+        $this->assertNotEquals($customDate, $doc7->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $doc7->getAttribute('$updatedAt'));
+
+        // Update with custom dates should also be ignored
+        $doc7->setAttribute('string', 'updated');
+        $doc7->setAttribute('$createdAt', $customDate);
+        $doc7->setAttribute('$updatedAt', $customDate);
+        $updatedDoc7 = $database->updateDocument($collection, 'doc7', $doc7);
+
+        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$updatedAt'));
 
-        $this->assertSame(2, $count);
-        $this->assertCount(2, $emittedIds);
-        \sort($emittedIds);
-        $this->assertSame(['doc1', 'doc3'], $emittedIds);
+        // Test checking updatedAt updates even old document exists
+        $database->setPreserveDates(true);
+        $doc11 = $database->createDocument($collection, new Document([
+            '$id' => 'doc11',
+            '$permissions' => [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())],
+            'string' => 'no_dates',
+            '$createdAt' => $customDate
+        ]));
 
-        $doc1 = $database->getDocument(__FUNCTION__, 'doc1');
-        $this->assertSame('Original A', $doc1->getAttribute('name'));
+        $newUpdatedAt = $doc11->getUpdatedAt();
 
-        $doc3 = $database->getDocument(__FUNCTION__, 'doc3');
-        $this->assertSame('New C', $doc3->getAttribute('name'));
+        $newDoc11 = new Document([
+            'string' => 'no_dates_update',
+        ]);
+        $updatedDoc7 = $database->updateDocument($collection, 'doc11', $newDoc11);
+        $this->assertNotEquals($newUpdatedAt, $updatedDoc7->getAttribute('$updatedAt'));
 
-        // Total should be 3 (doc1, doc2, doc3)
-        $all = $database->find(__FUNCTION__);
-        $this->assertCount(3, $all);
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
     }
 
-    public function testCreateDocumentsIgnoreAllDuplicates(): void
+    public function testBulkDocumentDateOperations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
+        $collection = 'bulk_date_operations';
+        $database->createCollection(new Collection(id: $collection));
+        $this->assertEquals(true, $database->createAttribute($collection, Attribute::string(key: 'string', size: 128)));
 
-        $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'name', Database::VAR_STRING, 128, true);
+        $database->setPreserveDates(true);
+
+        $createDate = '2000-01-01T10:00:00.000+00:00';
+        $updateDate = '2000-02-01T15:30:00.000+00:00';
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
 
-        // Insert initial document
-        $database->createDocuments(__FUNCTION__, [
+        // Test 1: Bulk create with different date configurations
+        $documents = [
             new Document([
-                '$id' => 'existing',
-                'name' => 'Original',
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
+                '$id' => 'doc1',
+                '$permissions' => $permissions,
+                'string' => 'doc1',
+                '$createdAt' => $createDate
             ]),
-        ]);
-
-        // With skipDuplicates, inserting only duplicates should succeed with no new rows
-        $emittedIds = [];
-        $collection = __FUNCTION__;
-        $count = $database->skipDuplicates(function () use ($database, $collection, &$emittedIds) {
-            return $database->createDocuments($collection, [
-                new Document([
-                    '$id' => 'existing',
-                    'name' => 'Duplicate',
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::create(Role::any()),
-                    ],
-                ]),
-            ], onNext: function (Document $doc) use (&$emittedIds) {
-                $emittedIds[] = $doc->getId();
-            });
-        });
-
-        $this->assertSame(1, $count);
-        $this->assertSame(['existing'], $emittedIds);
+            new Document([
+                '$id' => 'doc2',
+                '$permissions' => $permissions,
+                'string' => 'doc2',
+                '$updatedAt' => $updateDate
+            ]),
+            new Document([
+                '$id' => 'doc3',
+                '$permissions' => $permissions,
+                'string' => 'doc3',
+                '$createdAt' => $createDate,
+                '$updatedAt' => $updateDate
+            ]),
+            new Document([
+                '$id' => 'doc4',
+                '$permissions' => $permissions,
+                'string' => 'doc4'
+            ]),
+            new Document([
+                '$id' => 'doc5',
+                '$permissions' => $permissions,
+                'string' => 'doc5',
+                '$createdAt' => null
+            ]),
+            new Document([
+                '$id' => 'doc6',
+                '$permissions' => $permissions,
+                'string' => 'doc6',
+                '$updatedAt' => null
+            ])
+        ];
 
-        $doc = $database->getDocument(__FUNCTION__, 'existing');
-        $this->assertSame('Original', $doc->getAttribute('name'));
+        $database->createDocuments($collection, $documents);
 
-        // Still only 1 document
-        $all = $database->find(__FUNCTION__);
-        $this->assertCount(1, $all);
-    }
+        // Verify initial state
+        foreach (['doc1', 'doc3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+        }
 
-    public function testCreateDocumentsSkipDuplicatesEmptyBatch(): void
-    {
-        $database = $this->getDatabase();
+        foreach (['doc2', 'doc3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+        }
 
-        $collection = 'skipDupEmpty';
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, true);
+        foreach (['doc4', 'doc5', 'doc6'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertNotEmpty($doc->getAttribute('$createdAt'), "createdAt missing for $id");
+            $this->assertNotEmpty($doc->getAttribute('$updatedAt'), "updatedAt missing for $id");
+        }
 
-        $count = $database->skipDuplicates(fn () => $database->createDocuments($collection, []));
+        // Test 2: Bulk update with custom dates
+        $updateDoc = new Document([
+            'string' => 'updated',
+            '$createdAt' => $createDate,
+            '$updatedAt' => $updateDate
+        ]);
+        $ids = [];
+        foreach ($documents as $doc) {
+            $ids[] = $doc->getId();
+        }
+        $count = $database->updateDocuments($collection, $updateDoc, [
+            Query::equal('$id', $ids)
+        ]);
+        $this->assertEquals(6, $count);
 
-        $this->assertSame(0, $count);
-        $this->assertCount(0, $database->find($collection));
-    }
+        foreach (['doc1', 'doc3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+            $this->assertEquals('updated', $doc->getAttribute('string'), "string mismatch for $id");
+        }
 
-    public function testCreateDocumentsSkipDuplicatesNestedScope(): void
-    {
-        $database = $this->getDatabase();
+        foreach (['doc2', 'doc4','doc5','doc6'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
+            $this->assertEquals('updated', $doc->getAttribute('string'), "string mismatch for $id");
+        }
 
-        $collection = 'skipDupNested';
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, true);
+        // Test 3: Bulk update with preserve dates disabled
+        $database->setPreserveDates(false);
 
-        $makeDoc = fn (string $id, string $name) => new Document([
-            '$id' => $id,
-            'name' => $name,
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-            ],
+        $customDate = 'should be ignored anyways so no error';
+        $updateDocDisabled = new Document([
+            'string' => 'disabled_update',
+            '$createdAt' => $customDate,
+            '$updatedAt' => $customDate
         ]);
 
-        // Seed an existing doc
-        $database->createDocuments($collection, [$makeDoc('seed', 'Seed')]);
+        $countDisabled = $database->updateDocuments($collection, $updateDocDisabled);
+        $this->assertEquals(6, $countDisabled);
 
-        // Nested scope — inner scope runs inside outer scope.
-        // After inner exits, outer state should still be "skip enabled".
-        // After outer exits, state should restore to "skip disabled".
-        $countOuter = $database->skipDuplicates(function () use ($database, $collection, $makeDoc) {
-            // Inner scope: add dup + new
-            $countInner = $database->skipDuplicates(function () use ($database, $collection, $makeDoc) {
-                return $database->createDocuments($collection, [
-                    $makeDoc('seed', 'Dup'),
-                    $makeDoc('innerNew', 'InnerNew'),
-                ]);
-            });
-            $this->assertSame(2, $countInner);
+        // Test 4: Bulk update with preserve dates re-enabled
+        $database->setPreserveDates(true);
 
-            // Still inside outer scope — skip flag should still be on
-            return $database->createDocuments($collection, [
-                $makeDoc('seed', 'Dup2'),
-                $makeDoc('outerNew', 'OuterNew'),
-            ]);
-        });
-        $this->assertSame(2, $countOuter);
+        $newDate = '2000-03-01T20:45:00.000+00:00';
+        $updateDocEnabled = new Document([
+            'string' => 'enabled_update',
+            '$createdAt' => $newDate,
+            '$updatedAt' => $newDate
+        ]);
 
-        // After both scopes exit, skip flag is off again — a plain createDocuments
-        // call with a duplicate should throw.
-        $thrown = null;
-        try {
-            $database->createDocuments($collection, [$makeDoc('seed', 'ShouldThrow')]);
-        } catch (DuplicateException $e) {
-            $thrown = $e;
-        }
-        $this->assertNotNull($thrown, 'Plain createDocuments after nested scopes should throw on duplicate');
+        $countEnabled = $database->updateDocuments($collection, $updateDocEnabled);
+        $this->assertEquals(6, $countEnabled);
 
-        // Final state: seed + innerNew + outerNew
-        $all = $database->find($collection);
-        $ids = \array_map(fn (Document $d) => $d->getId(), $all);
-        \sort($ids);
-        $this->assertSame(['innerNew', 'outerNew', 'seed'], $ids);
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
     }
 
-    public function testCreateDocumentsSkipDuplicatesLargeBatch(): void
+    public function testCreateUpdateDocumentsMismatch(): void
     {
+        /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = 'skipDupLarge';
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'idx', Database::VAR_INTEGER, 0, true);
-
-        // Seed 50 docs
-        $seed = [];
-        for ($i = 0; $i < 50; $i++) {
-            $seed[] = new Document([
-                '$id' => 'doc_' . $i,
-                'idx' => $i,
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
-            ]);
-        }
-        $database->createDocuments($collection, $seed);
-
-        // Now call skipDuplicates with 300 docs: 50 existing (0-49) + 250 new (50-299).
-        // 300 > default INSERT_BATCH_SIZE, so this exercises the chunk loop.
-        $batch = [];
-        for ($i = 0; $i < 300; $i++) {
-            $batch[] = new Document([
-                '$id' => 'doc_' . $i,
-                'idx' => $i + 1000, // different value so we can detect if existing got overwritten
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
-            ]);
-        }
-
-        $emittedIds = [];
-        $count = $database->skipDuplicates(function () use ($database, $collection, $batch, &$emittedIds) {
-            return $database->createDocuments($collection, $batch, onNext: function (Document $doc) use (&$emittedIds) {
-                $emittedIds[] = $doc->getId();
-            });
-        });
-
-        $this->assertSame(300, $count);
-        $this->assertCount(300, $emittedIds);
+        // with different set of attributes
+        $colName = "docs_with_diff";
+        $database->createCollection(new Collection(id: $colName));
+        $database->createAttribute($colName, Attribute::string(key: 'key', size: 50, required: true));
+        $database->createAttribute($colName, Attribute::string(key: 'value', size: 50, default: 'value'));
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
+        $docs =  [
+            new Document([
+                '$id' => 'doc1',
+                'key' => 'doc1',
+            ]),
+            new Document([
+                '$id' => 'doc2',
+                'key' => 'doc2',
+                'value' => 'test',
+            ]),
+            new Document([
+                '$id' => 'doc3',
+                '$permissions' => $permissions,
+                'key' => 'doc3'
+            ]),
+        ];
+        $this->assertEquals(3, $database->createDocuments($colName, $docs));
+        // we should get only one document as read permission provided to the last document only
+        $addedDocs = $database->find($colName);
+        $this->assertCount(1, $addedDocs);
+        $doc = $addedDocs[0];
+        $this->assertEquals('doc3', $doc->getId());
+        $this->assertNotEmpty($doc->getPermissions());
+        $this->assertCount(3, $doc->getPermissions());
 
-        $seedDoc = $database->getDocument($collection, 'doc_25');
-        $this->assertSame(25, $seedDoc->getAttribute('idx'));
+        $database->createDocument($colName, new Document([
+            '$id' => 'doc4',
+            '$permissions' => $permissions,
+            'key' => 'doc4'
+        ]));
 
-        $newDoc = $database->getDocument($collection, 'doc_100');
-        $this->assertSame(1100, $newDoc->getAttribute('idx'));
+        $this->assertEquals(2, $database->updateDocuments($colName, new Document(['key' => 'new doc'])));
+        $doc = $database->getDocument($colName, 'doc4');
+        $this->assertEquals('doc4', $doc->getId());
+        $this->assertEquals('value', $doc->getAttribute('value'));
 
-        $total = $database->count($collection);
-        $this->assertSame(300, $total);
+        $addedDocs = $database->find($colName);
+        $this->assertCount(2, $addedDocs);
+        foreach ($addedDocs as $doc) {
+            $this->assertNotEmpty($doc->getPermissions());
+            $this->assertCount(3, $doc->getPermissions());
+            $this->assertEquals('value', $doc->getAttribute('value'));
+        }
+        $database->deleteCollection($colName);
     }
 
-    public function testCreateDocumentsSkipDuplicatesSecondCallSkipsAll(): void
+    public function testBypassStructureWithSupportForAttributes(): void
     {
+        /** @var Database $database */
         $database = $this->getDatabase();
+        // for schemaless the validation will be automatically skipped
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $collection = 'skipDupSecond';
-        $database->createCollection($collection);
-        $database->createAttribute($collection, 'name', Database::VAR_STRING, 128, true);
+        $collectionId = 'successive_update_single';
 
-        $makeBatch = fn (string $name) => \array_map(
-            fn (string $id) => new Document([
-                '$id' => $id,
-                'name' => $name,
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ],
-            ]),
-            ['a', 'b', 'c']
-        );
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'attrA', size: 50, required: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'attrB', size: 50, required: true));
 
-        // First call — all new
-        $firstCount = $database->skipDuplicates(
-            fn () => $database->createDocuments($collection, $makeBatch('First'))
-        );
-        $this->assertSame(3, $firstCount);
+        // bypass required
+        $database->disableValidation();
 
-        $emittedIds = [];
-        $secondCount = $database->skipDuplicates(function () use ($database, $collection, $makeBatch, &$emittedIds) {
-            return $database->createDocuments($collection, $makeBatch('Second'), onNext: function (Document $doc) use (&$emittedIds) {
-                $emittedIds[] = $doc->getId();
-            });
-        });
-        $this->assertSame(3, $secondCount);
-        \sort($emittedIds);
-        $this->assertSame(['a', 'b', 'c'], $emittedIds);
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())];
+        $docs = $database->createDocuments($collectionId, [
+            new Document(['attrA' => null,'attrB' => 'B','$permissions' => $permissions])
+        ]);
 
-        // All three should retain the First values
-        foreach (['a', 'b', 'c'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertSame('First', $doc->getAttribute('name'), "Doc {$id} should not have been overwritten");
+        $docs = $database->find($collectionId);
+        foreach ($docs as $doc) {
+            $this->assertArrayHasKey('attrA', $doc->getAttributes());
+            $this->assertNull($doc->getAttribute('attrA'));
+            $this->assertEquals('B', $doc->getAttribute('attrB'));
+        }
+        // reset
+        $database->enableValidation();
+
+        try {
+            $database->createDocuments($collectionId, [
+                new Document(['attrA' => null,'attrB' => 'B','$permissions' => $permissions])
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
         }
+
+        $database->deleteCollection($collectionId);
     }
 
-    public function testCreateDocumentsSkipDuplicatesRelationships(): void
+    public function testValidationGuardsWithNullRequired(): void
     {
+        /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $parent = 'skipDupParent';
-        $child = 'skipDupChild';
-        $permissions = [
+        // Base collection and attributes
+        $collection = 'validation_guard_all';
+        $database->createCollection(new Collection(id: $collection, permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
             Permission::delete(Role::any()),
-        ];
+        ]));
+        $database->createAttribute($collection, Attribute::string(key: 'name', size: 32, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'age', required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'value'));
 
-        $database->createCollection($parent);
-        $database->createCollection($child);
-        $database->createAttribute($parent, 'name', Database::VAR_STRING, 128, true);
-        $database->createAttribute($child, 'name', Database::VAR_STRING, 128, true);
-        $database->createRelationship(
-            collection: $parent,
-            relatedCollection: $child,
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'children',
-        );
+        // 1) createDocument with null required should fail when validation enabled, pass when disabled
+        try {
+            $database->createDocument($collection, new Document([
+                '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
+                'name' => null,
+                'age' => null,
+            ]));
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
 
-        $database->createDocument($parent, new Document([
-            '$id' => 'existingParent',
-            'name' => 'ExistingParent',
-            '$permissions' => $permissions,
-            'children' => [
-                new Document([
-                    '$id' => 'existingChild',
-                    'name' => 'ExistingChild',
-                    '$permissions' => $permissions,
-                ]),
-            ],
+        $database->disableValidation();
+        $doc = $database->createDocument($collection, new Document([
+            '$id' => 'created-null',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            'name' => null,
+            'age' => null,
         ]));
+        $this->assertEquals('created-null', $doc->getId());
+        $database->enableValidation();
 
-        $batch = [
-            new Document([
-                '$id' => 'existingParent',
-                'name' => 'ShouldNotOverwrite',
-                '$permissions' => $permissions,
-                'children' => [
-                    new Document([
-                        '$id' => 'existingChild',
-                        'name' => 'ExistingChild',
-                        '$permissions' => $permissions,
-                    ]),
-                    new Document([
-                        '$id' => 'retryChild',
-                        'name' => 'RetryChild',
-                        '$permissions' => $permissions,
-                    ]),
-                ],
-            ]),
-            new Document([
-                '$id' => 'newParent',
-                'name' => 'NewParent',
-                '$permissions' => $permissions,
-                'children' => [
-                    new Document([
-                        '$id' => 'newChild',
-                        'name' => 'NewChild',
-                        '$permissions' => $permissions,
-                    ]),
-                ],
-            ]),
-        ];
+        // Seed a valid document for updates
+        $valid = $database->createDocument($collection, new Document([
+            '$id' => 'valid',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'ok',
+            'age' => 10,
+        ]));
+        $this->assertEquals('valid', $valid->getId());
+
+        // 2) updateDocument set required to null should fail when validation enabled, pass when disabled
+        try {
+            $database->updateDocument($collection, 'valid', new Document([
+                'age' => null,
+            ]));
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+
+        $database->disableValidation();
+        $updated = $database->updateDocument($collection, 'valid', new Document([
+            'age' => null,
+        ]));
+        $this->assertNull($updated->getAttribute('age'));
+        $database->enableValidation();
+
+        // Seed a few valid docs for bulk update
+        for ($i = 0; $i < 2; $i++) {
+            $database->createDocument($collection, new Document([
+                '$id' => 'b' . $i,
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+                'name' => 'ok',
+                'age' => 1,
+            ]));
+        }
 
-        $database->skipDuplicates(fn () => $database->createDocuments($parent, $batch));
+        // 3) updateDocuments setting required to null should fail when validation enabled, pass when disabled
+        if ($database->getAdapter()->supports(Capability::BatchOperations)) {
+            try {
+                $database->updateDocuments($collection, new Document([
+                    'name' => null,
+                ]));
+                $this->fail('Failed to throw exception');
+            } catch (Throwable $e) {
+                $this->assertInstanceOf(StructureException::class, $e);
+            }
 
-        $existing = $database->getDocument($parent, 'existingParent');
-        $this->assertFalse($existing->isEmpty());
-        $this->assertSame('ExistingParent', $existing->getAttribute('name'));
+            $database->disableValidation();
+            $count = $database->updateDocuments($collection, new Document([
+                'name' => null,
+            ]));
+            $this->assertGreaterThanOrEqual(3, $count); // at least the seeded docs are updated
+            $database->enableValidation();
+        }
 
-        $existingChildren = $existing->getAttribute('children', []);
-        $childIds = \array_map(fn (Document $d) => $d->getId(), $existingChildren);
-        \sort($childIds);
-        $this->assertSame(['existingChild', 'retryChild'], $childIds);
+        // 4) upsertDocumentsWithIncrease with null required should fail when validation enabled, pass when disabled
+        if ($database->getAdapter()->hasFeature(Feature\Upserts::class)) {
+            try {
+                $database->upsertDocumentsWithIncrease(
+                    collection: $collection,
+                    attribute: 'value',
+                    documents: [new Document([
+                        '$id' => 'u1',
+                        'name' => null, // required null
+                        'value' => 1,
+                    ])]
+                );
+                $this->fail('Failed to throw exception');
+            } catch (Throwable $e) {
+                $this->assertInstanceOf(StructureException::class, $e);
+            }
 
-        $new = $database->getDocument($parent, 'newParent');
-        $this->assertFalse($new->isEmpty());
-        $this->assertSame('NewParent', $new->getAttribute('name'));
-        $newChildren = $new->getAttribute('children', []);
-        $this->assertCount(1, $newChildren);
-        $this->assertSame('newChild', $newChildren[0]->getId());
+            $database->disableValidation();
+            $ucount = $database->upsertDocumentsWithIncrease(
+                collection: $collection,
+                attribute: 'value',
+                documents: [new Document([
+                    '$id' => 'u1',
+                    'name' => null,
+                    'value' => 1,
+                ])]
+            );
+            $this->assertEquals(1, $ucount);
+            $database->enableValidation();
+        }
 
-        $allChildren = $database->find($child);
-        $allChildIds = \array_map(fn (Document $d) => $d->getId(), $allChildren);
-        \sort($allChildIds);
-        $this->assertSame(['existingChild', 'newChild', 'retryChild'], $allChildIds);
+        // Cleanup
+        $database->deleteCollection($collection);
     }
 
+    /**
+     * Load the active epoch-addressed point-cache entry for a document.
+     */
+    private function loadDocumentPointCache(Database $database, string $collection, string $id, string ...$selections): mixed
+    {
+        [$collectionKey, , $hashKey] = $database->getCacheKeys($collection, $id, $selections);
+        $cache = $database->getCache();
+        $epoch = $cache->load($collectionKey.'#epoch', Database::TTL);
+        if (! \is_string($epoch) || $epoch === '') {
+            return false;
+        }
+
+        return $cache->load($hashKey.'#'.$epoch, Database::TTL);
+    }
 
     public function testDropUnknownAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -9256,8 +8347,8 @@ public function testDropUnknownAttributes(): void
             Permission::delete(Role::any()),
         ];
 
-        $database->createCollection(__FUNCTION__);
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'known', Database::VAR_STRING, 128, false));
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, Attribute::string(key: 'known', size: 128)));
 
         try {
             $database->createDocument(__FUNCTION__, new Document([
diff --git a/tests/e2e/Adapter/Scopes/GeneralTests.php b/tests/e2e/Adapter/Scopes/GeneralTests.php
index 2057197fd1..f9da5d06e0 100644
--- a/tests/e2e/Adapter/Scopes/GeneralTests.php
+++ b/tests/e2e/Adapter/Scopes/GeneralTests.php
@@ -2,11 +2,10 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
-use Exception;
-use Throwable;
-use Utopia\Cache\Adapter\Redis as RedisAdapter;
-use Utopia\Cache\Cache;
-use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
@@ -14,13 +13,12 @@
 use Utopia\Database\Exception\Conflict as ConflictException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
-use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
-use Utopia\Database\Mirror;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
 
 trait GeneralTests
@@ -40,35 +38,30 @@ public function testPing(): void
      */
     public function testQueryTimeout(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForTimeouts()) {
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Timeouts::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('global-timeouts');
+        $database->createCollection(new Collection(id: 'global-timeouts'));
 
         $this->assertEquals(
             true,
-            $database->createAttribute(
-                collection: 'global-timeouts',
-                id: 'longtext',
-                type: Database::VAR_STRING,
-                size: 100000000,
-                required: true
-            )
+            $database->createAttribute('global-timeouts', Attribute::string(key: 'longtext', size: 100000000, required: true))
         );
 
         for ($i = 0; $i < 20; $i++) {
             $database->createDocument('global-timeouts', new Document([
-                'longtext' => file_get_contents(__DIR__ . '/../../../resources/longtext.txt'),
+                'longtext' => file_get_contents(__DIR__.'/../../../resources/longtext.txt'),
                 '$permissions' => [
                     Permission::read(Role::any()),
                     Permission::update(Role::any()),
-                    Permission::delete(Role::any())
-                ]
+                    Permission::delete(Role::any()),
+                ],
             ]));
         }
 
@@ -86,405 +79,62 @@ public function testQueryTimeout(): void
         }
     }
 
-    public function testCountTimeout(): void
-    {
-        if (!$this->getDatabase()->getAdapter()->getSupportForTimeouts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection('count-timeouts');
-
-        $this->assertEquals(
-            true,
-            $database->createAttribute(
-                collection: 'count-timeouts',
-                id: 'longtext',
-                type: Database::VAR_STRING,
-                size: 100000000,
-                required: true
-            )
-        );
-
-        $longtext = file_get_contents(__DIR__ . '/../../../resources/longtext.txt');
-        for ($i = 0; $i < 20; $i++) {
-            $database->createDocument('count-timeouts', new Document([
-                'longtext' => $longtext,
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                    Permission::update(Role::any()),
-                    Permission::delete(Role::any())
-                ]
-            ]));
-        }
-
-        try {
-            $database->setTimeout(1);
-
-            $thrown = null;
-            try {
-                // A substring scan forces the engine to walk every huge value; a
-                // cheap filter (e.g. notEqual) lets COUNT finish inside the timeout.
-                $database->count('count-timeouts', [
-                    Query::contains('longtext', ['needle-that-does-not-exist']),
-                ]);
-            } catch (\Exception $e) {
-                $thrown = $e;
-            }
-
-            $this->assertInstanceOf(TimeoutException::class, $thrown, 'count() must throw a timeout exception');
-        } finally {
-            $database->clearTimeout();
-            $database->deleteCollection('count-timeouts');
-        }
-    }
-
-    public function testPreserveDatesUpdate(): void
-    {
-        $this->getDatabase()->getAuthorization()->disable();
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->setPreserveDates(true);
-
-        $database->createCollection('preserve_update_dates');
-
-        $database->createAttribute('preserve_update_dates', 'attr1', Database::VAR_STRING, 10, false);
-
-        $doc1 = $database->createDocument('preserve_update_dates', new Document([
-            '$id' => 'doc1',
-            '$permissions' => [],
-            'attr1' => 'value1',
-        ]));
-
-        $doc2 = $database->createDocument('preserve_update_dates', new Document([
-            '$id' => 'doc2',
-            '$permissions' => [],
-            'attr1' => 'value2',
-        ]));
-
-        $doc3 = $database->createDocument('preserve_update_dates', new Document([
-            '$id' => 'doc3',
-            '$permissions' => [],
-            'attr1' => 'value3',
-        ]));
-        // updating with empty dates
-        try {
-            $doc1->setAttribute('$updatedAt', '');
-            $doc1 = $database->updateDocument('preserve_update_dates', 'doc1', $doc1);
-            $this->fail('Failed to throw structure exception');
-
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-            $this->assertEquals('Invalid document structure: Missing required attribute "$updatedAt"', $e->getMessage());
-        }
-
-        try {
-            $this->getDatabase()->updateDocuments(
-                'preserve_update_dates',
-                new Document([
-                    '$updatedAt' => ''
-                ]),
-                [
-                    Query::equal('$id', [
-                        $doc2->getId(),
-                        $doc3->getId()
-                    ])
-                ]
-            );
-            $this->fail('Failed to throw structure exception');
-
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-            $this->assertEquals('Invalid document structure: Missing required attribute "$updatedAt"', $e->getMessage());
-        }
-
-        // non empty dates
-        $newDate = '2000-01-01T10:00:00.000+00:00';
-
-        $doc1->setAttribute('$updatedAt', $newDate);
-        $doc1 = $database->updateDocument('preserve_update_dates', 'doc1', $doc1);
-        $this->assertEquals($newDate, $doc1->getAttribute('$updatedAt'));
-        $doc1 = $database->getDocument('preserve_update_dates', 'doc1');
-        $this->assertEquals($newDate, $doc1->getAttribute('$updatedAt'));
-
-        $this->getDatabase()->updateDocuments(
-            'preserve_update_dates',
-            new Document([
-                '$updatedAt' => $newDate
-            ]),
-            [
-                Query::equal('$id', [
-                    $doc2->getId(),
-                    $doc3->getId()
-                ])
-            ]
-        );
-
-        $doc2 = $database->getDocument('preserve_update_dates', 'doc2');
-        $doc3 = $database->getDocument('preserve_update_dates', 'doc3');
-        $this->assertEquals($newDate, $doc2->getAttribute('$updatedAt'));
-        $this->assertEquals($newDate, $doc3->getAttribute('$updatedAt'));
-
-        $database->deleteCollection('preserve_update_dates');
-
-        $database->setPreserveDates(false);
-
-        $this->getDatabase()->getAuthorization()->reset();
-    }
-
-    public function testPreserveDatesCreate(): void
-    {
-        $this->getDatabase()->getAuthorization()->disable();
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->setPreserveDates(true);
-
-        $database->createCollection('preserve_create_dates');
-
-        $database->createAttribute('preserve_create_dates', 'attr1', Database::VAR_STRING, 10, false);
-
-        // empty string for $createdAt should throw Structure exception
-        try {
-            $date = '';
-            $database->createDocument('preserve_create_dates', new Document([
-                '$id' => 'doc1',
-                '$permissions' => [],
-                'attr1' => 'value1',
-                '$createdAt' => $date
-            ]));
-            $this->fail('Failed to throw structure exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-            $this->assertEquals('Invalid document structure: Missing required attribute "$createdAt"', $e->getMessage());
-        }
-
-        try {
-            $database->createDocuments('preserve_create_dates', [
-                new Document([
-                    '$id' => 'doc2',
-                    '$permissions' => [],
-                    'attr1' => 'value2',
-                    '$createdAt' => $date
-                ]),
-                new Document([
-                    '$id' => 'doc3',
-                    '$permissions' => [],
-                    'attr1' => 'value3',
-                    '$createdAt' => $date
-                ]),
-            ], batchSize: 2);
-            $this->fail('Failed to throw structure exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-            $this->assertEquals('Invalid document structure: Missing required attribute "$createdAt"', $e->getMessage());
-        }
-
-        // non empty date
-        $date = '2000-01-01T10:00:00.000+00:00';
-
-        $database->createDocument('preserve_create_dates', new Document([
-            '$id' => 'doc1',
-            '$permissions' => [],
-            'attr1' => 'value1',
-            '$createdAt' => $date
-        ]));
-
-        $database->createDocuments('preserve_create_dates', [
-            new Document([
-                '$id' => 'doc2',
-                '$permissions' => [],
-                'attr1' => 'value2',
-                '$createdAt' => $date
-            ]),
-            new Document([
-                '$id' => 'doc3',
-                '$permissions' => [],
-                'attr1' => 'value3',
-                '$createdAt' => $date,
-            ]),
-            new Document([
-                '$id' => 'doc4',
-                '$permissions' => [],
-                'attr1' => 'value3',
-                '$createdAt' => null,
-            ]),
-            new Document([
-                '$id' => 'doc5',
-                '$permissions' => [],
-                'attr1' => 'value3',
-            ]),
-        ], batchSize: 2);
-
-        $doc1 = $database->getDocument('preserve_create_dates', 'doc1');
-        $doc2 = $database->getDocument('preserve_create_dates', 'doc2');
-        $doc3 = $database->getDocument('preserve_create_dates', 'doc3');
-        $doc4 = $database->getDocument('preserve_create_dates', 'doc4');
-        $doc5 = $database->getDocument('preserve_create_dates', 'doc5');
-        $this->assertEquals($date, $doc1->getAttribute('$createdAt'));
-        $this->assertEquals($date, $doc2->getAttribute('$createdAt'));
-        $this->assertEquals($date, $doc3->getAttribute('$createdAt'));
-        $this->assertNotEmpty($date, $doc4->getAttribute('$createdAt'));
-        $this->assertNotEquals($date, $doc4->getAttribute('$createdAt'));
-        $this->assertNotEmpty($date, $doc5->getAttribute('$createdAt'));
-        $this->assertNotEquals($date, $doc5->getAttribute('$createdAt'));
-
-        $database->deleteCollection('preserve_create_dates');
-
-        $database->setPreserveDates(false);
-
-        $this->getDatabase()->getAuthorization()->reset();
-    }
-
-    public function testGetAttributeLimit(): void
-    {
-        $this->assertIsInt($this->getDatabase()->getLimitForAttributes());
-    }
-    public function testGetIndexLimit(): void
-    {
-        $this->assertEquals(58, $this->getDatabase()->getLimitForIndexes());
-    }
-
-    public function testGetId(): void
-    {
-        $this->assertEquals(20, strlen(ID::unique()));
-        $this->assertEquals(13, strlen(ID::unique(0)));
-        $this->assertEquals(13, strlen(ID::unique(-1)));
-        $this->assertEquals(23, strlen(ID::unique(10)));
-
-        // ensure two sequential calls to getId do not give the same result
-        $this->assertNotEquals(ID::unique(10), ID::unique(10));
-    }
-
     public function testSharedTablesUpdateTenant(): void
     {
         $database = $this->getDatabase();
         $sharedTables = $database->getSharedTables();
         $namespace = $database->getNamespace();
         $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
 
-        if (!$database->getAdapter()->getSupportForSchemas()) {
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if ($database->exists('sharedTables')) {
-            $database->setDatabase('sharedTables')->delete();
+        $sharedTablesDb = 'sharedTables_'.static::getTestToken();
+
+        if ($database->exists($sharedTablesDb)) {
+            $database->setDatabase($sharedTablesDb)->delete();
         }
 
         $database
-            ->setDatabase('sharedTables')
+            ->setDatabase($sharedTablesDb)
             ->setNamespace('')
             ->setSharedTables(true)
             ->setTenant(null)
             ->create();
 
-        // Create collection
-        $database->createCollection(__FUNCTION__, documentSecurity: false);
-
-        $database
-            ->setTenant(1)
-            ->updateDocument(Database::METADATA, __FUNCTION__, new Document([
-                '$id' => __FUNCTION__,
-                'name' => 'Scooby Doo',
-            ]));
-
-        // Ensure tenant was not swapped
-        $doc = $database
-            ->setTenant(null)
-            ->getDocument(Database::METADATA, __FUNCTION__);
-
-        $this->assertEquals('Scooby Doo', $doc['name']);
-
-        // Reset state
-        $database
-            ->setSharedTables($sharedTables)
-            ->setNamespace($namespace)
-            ->setDatabase($schema);
-    }
-
-
-    public function testFindOrderByAfterException(): void
-    {
-        /**
-         * ORDER BY - After Exception
-         * Must be last assertion in test
-         */
-        $document = new Document([
-            '$collection' => 'other collection'
-        ]);
-
-        $this->expectException(Exception::class);
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($document)
-        ]);
-    }
+        try {
+            $database->createCollection(new Collection(id: __FUNCTION__, documentSecurity: false));
 
+            $database
+                ->setTenant(1)
+                ->updateDocument(Database::METADATA, __FUNCTION__, new Document([
+                    '$id' => __FUNCTION__,
+                    'name' => 'Scooby Doo',
+                ]));
 
-    public function testNestedQueryValidation(): void
-    {
-        $this->getDatabase()->createCollection(__FUNCTION__, [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => true,
-            ])
-        ], permissions: [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-
-        $this->getDatabase()->createDocuments(__FUNCTION__, [
-            new Document([
-                '$id' => ID::unique(),
-                'name' => 'test1',
-            ]),
-            new Document([
-                '$id' => ID::unique(),
-                'name' => 'doc2',
-            ]),
-        ]);
+            $database->setTenant(null);
+            $database->purgeCachedDocument(Database::METADATA, __FUNCTION__);
+            $doc = $database->getDocument(Database::METADATA, __FUNCTION__);
 
-        try {
-            $this->getDatabase()->find(__FUNCTION__, [
-                Query::or([
-                    Query::equal('name', ['test1']),
-                    Query::search('name', 'doc'),
-                ])
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(QueryException::class, $e);
-            $this->assertEquals('Searching by attribute "name" requires a fulltext index.', $e->getMessage());
+            $this->assertFalse($doc->isEmpty());
+            $this->assertEquals(__FUNCTION__, $doc->getId());
+        } finally {
+            $database->setTenant(null)->setSharedTables(false);
+            if ($database->exists($sharedTablesDb)) {
+                $database->delete($sharedTablesDb);
+            }
+            $database
+                ->setSharedTables($sharedTables)
+                ->setTenant($tenant)
+                ->setNamespace($namespace)
+                ->setDatabase($schema);
         }
     }
 
-
     public function testSharedTablesTenantPerDocument(): void
     {
         /** @var Database $database */
@@ -494,32 +144,40 @@ public function testSharedTablesTenantPerDocument(): void
         $tenantPerDocument = $database->getTenantPerDocument();
         $namespace = $database->getNamespace();
         $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
 
-        if (!$database->getAdapter()->getSupportForSchemas()) {
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if ($database->exists('sharedTablesTenantPerDocument')) {
-            $database->delete('sharedTablesTenantPerDocument');
+        if (getenv('ENABLE_TENANT_PER_DOCUMENT_TEST') !== '1') {
+            $this->markTestSkipped('tenantPerDocument requires collection-level tenant bypass (not yet implemented)');
+        }
+
+        $tenantPerDocDb = 'sharedTablesTenantPerDocument_'.static::getTestToken();
+
+        if ($database->exists($tenantPerDocDb)) {
+            $database->delete($tenantPerDocDb);
         }
 
         $database
-            ->setDatabase('sharedTablesTenantPerDocument')
+            ->setDatabase($tenantPerDocDb)
             ->setNamespace('')
             ->setSharedTables(true)
             ->setTenant(null)
             ->create();
 
         // Create collection
-        $database->createCollection(__FUNCTION__, permissions: [
+        $database->createCollection(new Collection(id: __FUNCTION__, permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::update(Role::any()),
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
-        $database->createAttribute(__FUNCTION__, 'name', Database::VAR_STRING, 100, false);
-        $database->createIndex(__FUNCTION__, 'nameIndex', Database::INDEX_KEY, ['name']);
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'name', size: 100));
+        $database->createIndex(__FUNCTION__, Index::key(key: 'nameIndex', attributes: ['name']));
 
         $doc1Id = ID::unique();
 
@@ -571,7 +229,7 @@ public function testSharedTablesTenantPerDocument(): void
         $this->assertEquals(1, \count($docs));
         $this->assertEquals($doc1Id, $docs[0]->getId());
 
-        if ($database->getAdapter()->getSupportForUpserts()) {
+        if ($database->getAdapter()->hasFeature(Feature\Upserts::class)) {
             // Test upsert with tenant per doc
             $doc3Id = ID::unique();
             $database
@@ -680,171 +338,58 @@ public function testSharedTablesTenantPerDocument(): void
         $database
             ->setSharedTables($sharedTables)
             ->setTenantPerDocument($tenantPerDocument)
+            ->setTenant($tenant)
             ->setNamespace($namespace)
             ->setDatabase($schema);
     }
 
-
-    public function testCacheFallback(): void
+    public function testCacheFallbackOnFailure(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForCacheSkipOnFailure()) {
+        if (! $database->getAdapter()->supports(Capability::CacheSkipOnFailure)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-
-        // Write mock data
-        $database->createCollection('testRedisFallback', attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'size' => 767,
-                'required' => true,
-            ])
+        $collection = 'cacheFallback_'.uniqid();
+
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'title', size: 128, required: true),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+        ]));
 
-        $database->createDocument('testRedisFallback', new Document([
+        $database->createDocument($collection, new Document([
             '$id' => 'doc1',
-            'string' => 'text📝',
+            'title' => 'hello',
         ]));
 
-        $database->createIndex('testRedisFallback', 'index1', Database::INDEX_KEY, ['string']);
-        $this->assertCount(1, $database->find('testRedisFallback', [Query::equal('string', ['text📝'])]));
+        $this->assertCount(1, $database->find($collection));
 
-        // Bring down Redis
-        $stdout = '';
-        $stderr = '';
-        Console::execute('docker ps -a --filter "name=utopia-redis" --format "{{.Names}}" | xargs -r docker stop', "", $stdout, $stderr);
+        $brokenRedis = $this->createMock(\Redis::class);
+        $brokenRedis->method('get')->willThrowException(new \RedisException('gone'));
+        $brokenRedis->method('set')->willThrowException(new \RedisException('gone'));
+        $brokenRedis->method('del')->willThrowException(new \RedisException('gone'));
+        $brokenRedis->method('expire')->willThrowException(new \RedisException('gone'));
 
-        // Check we can read data still
-        $this->assertCount(1, $database->find('testRedisFallback', [Query::equal('string', ['text📝'])]));
-        $this->assertFalse(($database->getDocument('testRedisFallback', 'doc1'))->isEmpty());
+        $brokenAdapter = new \Utopia\Cache\Adapter\Redis($brokenRedis);
+        $brokenAdapter->setMaxRetries(0);
+        $originalCache = $database->getCache();
+        $database->setCache(new \Utopia\Cache\Cache($brokenAdapter));
 
-        // Check we cannot modify data
-        try {
-            $database->updateDocument('testRedisFallback', 'doc1', new Document([
-                'string' => 'text📝 updated',
-            ]));
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertEquals('Redis server redis:6379 went away', $e->getMessage());
-        }
+        $doc = $database->getDocument($collection, 'doc1');
+        $this->assertFalse($doc->isEmpty());
+        $this->assertEquals('hello', $doc->getAttribute('title'));
 
-        try {
-            $database->deleteDocument('testRedisFallback', 'doc1');
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertEquals('Redis server redis:6379 went away', $e->getMessage());
-        }
-
-        // Bring backup Redis
-        Console::execute('docker ps -a --filter "name=utopia-redis" --format "{{.Names}}" | xargs -r docker start', "", $stdout, $stderr);
-        sleep(5);
+        $results = $database->find($collection);
+        $this->assertCount(1, $results);
 
-        $this->assertCount(1, $database->find('testRedisFallback', [Query::equal('string', ['text📝'])]));
-    }
-
-    public function testCacheReconnect(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForCacheSkipOnFailure()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Wait for Redis to be fully healthy after previous test
-        $this->waitForRedis();
-
-        // Create new cache with reconnection enabled
-        $redis = new \Redis();
-        $redis->connect('redis', 6379);
-        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
-
-        // For Mirror, we need to set cache on both source and destination
-        if ($database instanceof Mirror) {
-            $database->getSource()->setCache($cache);
-
-            $mirrorRedis = new \Redis();
-            $mirrorRedis->connect('redis-mirror', 6379);
-            $mirrorCache = new Cache((new RedisAdapter($mirrorRedis))->setMaxRetries(3));
-            $database->getDestination()->setCache($mirrorCache);
-        }
-
-        $database->setCache($cache);
-
-        $database->getAuthorization()->cleanRoles();
-        $database->getAuthorization()->addRole(Role::any()->toString());
-
-        try {
-            $database->createCollection('testCacheReconnect', attributes: [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'size' => 255,
-                    'required' => true,
-                ])
-            ], permissions: [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any())
-            ]);
-
-            $database->createDocument('testCacheReconnect', new Document([
-                '$id' => 'reconnect_doc',
-                'title' => 'Test Document',
-            ]));
-
-            // Cache the document
-            $doc = $database->getDocument('testCacheReconnect', 'reconnect_doc');
-            $this->assertEquals('Test Document', $doc->getAttribute('title'));
-
-            // Bring down Redis
-            $stdout = '';
-            $stderr = '';
-            Console::execute('docker ps -a --filter "name=utopia-redis" --format "{{.Names}}" | xargs -r docker stop', "", $stdout, $stderr);
-            sleep(1);
-
-            // Bring back Redis
-            Console::execute('docker ps -a --filter "name=utopia-redis" --format "{{.Names}}" | xargs -r docker start', "", $stdout, $stderr);
-            $this->waitForRedis();
-
-            // Cache should reconnect - read should work
-            $doc = $database->getDocument('testCacheReconnect', 'reconnect_doc');
-            $this->assertEquals('Test Document', $doc->getAttribute('title'));
-
-            // Update should work after reconnect
-            $database->updateDocument('testCacheReconnect', 'reconnect_doc', new Document([
-                '$id' => 'reconnect_doc',
-                'title' => 'Updated Title',
-            ]));
-
-            $doc = $database->getDocument('testCacheReconnect', 'reconnect_doc');
-            $this->assertEquals('Updated Title', $doc->getAttribute('title'));
-        } finally {
-            // Ensure Redis is running
-            $stdout = '';
-            $stderr = '';
-            Console::execute('docker ps -a --filter "name=utopia-redis" --format "{{.Names}}" | xargs -r docker start', "", $stdout, $stderr);
-            $this->waitForRedis();
-
-            // Cleanup collection if it exists
-            if ($database->exists() && !$database->getCollection('testCacheReconnect')->isEmpty()) {
-                $database->deleteCollection('testCacheReconnect');
-            }
-        }
+        $database->setCache($originalCache);
+        $database->deleteCollection($collection);
     }
 
     /**
@@ -857,8 +402,8 @@ public function testTransactionAtomicity(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('transactionAtomicity');
-        $database->createAttribute('transactionAtomicity', 'title', Database::VAR_STRING, 128, true);
+        $database->createCollection(new Collection(id: 'transactionAtomicity'));
+        $database->createAttribute('transactionAtomicity', Attribute::string(key: 'title', size: 128, required: true));
 
         // Verify a successful transaction commits
         $doc = $database->withTransaction(function () use ($database) {
@@ -908,8 +453,8 @@ public function testTransactionStateAfterKnownException(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('txKnownException');
-        $database->createAttribute('txKnownException', 'title', Database::VAR_STRING, 128, true);
+        $database->createCollection(new Collection(id: 'txKnownException'));
+        $database->createAttribute('txKnownException', Attribute::string(key: 'title', size: 128, required: true));
 
         $database->createDocument('txKnownException', new Document([
             '$id' => 'existing_doc',
@@ -960,8 +505,9 @@ public function testTransactionStateAfterRetriesExhausted(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForTransactionRetries()) {
+        if (! $database->getAdapter()->supports(Capability::TransactionRetries)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -998,13 +544,14 @@ public function testNestedTransactionState(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForNestedTransactions()) {
+        if (! $database->getAdapter()->supports(Capability::NestedTransactions)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('txNested');
-        $database->createAttribute('txNested', 'title', Database::VAR_STRING, 128, true);
+        $database->createCollection(new Collection(id: 'txNested'));
+        $database->createAttribute('txNested', Attribute::string(key: 'title', size: 128, required: true));
 
         $database->createDocument('txNested', new Document([
             '$id' => 'nested_existing',
@@ -1015,7 +562,7 @@ public function testNestedTransactionState(): void
         ]));
 
         // Outer transaction should succeed even if inner transaction throws
-        $result = $database->withTransaction(function () use ($database) {
+        $database->withTransaction(function () use ($database) {
             $database->createDocument('txNested', new Document([
                 '$id' => 'outer_doc',
                 '$permissions' => [
@@ -1042,8 +589,6 @@ public function testNestedTransactionState(): void
             return true;
         });
 
-        $this->assertTrue($result);
-
         // inTransaction must be false after everything completes
         $this->assertFalse(
             $database->getAdapter()->inTransaction(),
@@ -1065,17 +610,4 @@ public function testNestedTransactionState(): void
     /**
      * Wait for Redis to be ready with a readiness probe
      */
-    private function waitForRedis(int $maxRetries = 10, int $delayMs = 500): void
-    {
-        for ($i = 0; $i < $maxRetries; $i++) {
-            try {
-                $redis = new \Redis();
-                $redis->connect('redis', 6379);
-                $redis->ping();
-                return;
-            } catch (\RedisException $e) {
-                usleep($delayMs * 1000);
-            }
-        }
-    }
 }
diff --git a/tests/e2e/Adapter/Scopes/IndexTests.php b/tests/e2e/Adapter/Scopes/IndexTests.php
index 13dd31d154..c3436aab50 100644
--- a/tests/e2e/Adapter/Scopes/IndexTests.php
+++ b/tests/e2e/Adapter/Scopes/IndexTests.php
@@ -4,17 +4,20 @@
 
 use Exception;
 use Throwable;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
-use Utopia\Database\Exception\Limit as LimitException;
-use Utopia\Database\Exception\Query as QueryException;
-use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Index;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 
 trait IndexTests
 {
@@ -22,29 +25,29 @@ public function testCreateIndex(): void
     {
         $database = $this->getDatabase();
 
-        $database->createCollection('indexes');
+        $database->createCollection(new Collection(id: 'indexes'));
 
         /**
          * Check ticks sounding cast index for reserved words
          */
-        $database->createAttribute('indexes', 'int', Database::VAR_INTEGER, 8, false, array:true);
-        if ($database->getAdapter()->getSupportForIndexArray()) {
-            $database->createIndex('indexes', 'indx8711', Database::INDEX_KEY, ['int'], [255]);
+        $database->createAttribute('indexes', Attribute::integer(key: 'int', size: 8, array: true));
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            $database->createIndex('indexes', Index::key(key: 'indx8711', attributes: ['int'], lengths: [255]));
         }
 
-        $database->createAttribute('indexes', 'name', Database::VAR_STRING, 10, false);
+        $database->createAttribute('indexes', Attribute::string(key: 'name', size: 10));
 
-        $database->createIndex('indexes', 'index_1', Database::INDEX_KEY, ['name']);
+        $database->createIndex('indexes', Index::key(key: 'index_1', attributes: ['name']));
 
         try {
-            $database->createIndex('indexes', 'index3', Database::INDEX_KEY, ['$id', '$id']);
+            $database->createIndex('indexes', Index::key(key: 'index3', attributes: ['$id', '$id']));
         } catch (Throwable $e) {
             self::assertTrue($e instanceof DatabaseException);
             self::assertEquals($e->getMessage(), 'Duplicate attributes provided');
         }
 
         try {
-            $database->createIndex('indexes', 'index4', Database::INDEX_KEY, ['name', 'Name']);
+            $database->createIndex('indexes', Index::key(key: 'index4', attributes: ['name', 'Name']));
         } catch (Throwable $e) {
             self::assertTrue($e instanceof DatabaseException);
             self::assertEquals($e->getMessage(), 'Duplicate attributes provided');
@@ -58,24 +61,24 @@ public function testCreateDeleteIndex(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('indexes');
+        $database->createCollection(new Collection(id: 'indexes'));
 
-        $this->assertEquals(true, $database->createAttribute('indexes', 'string', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('indexes', 'order', Database::VAR_STRING, 128, true));
-        $this->assertEquals(true, $database->createAttribute('indexes', 'integer', Database::VAR_INTEGER, 0, true));
-        $this->assertEquals(true, $database->createAttribute('indexes', 'float', Database::VAR_FLOAT, 0, true));
-        $this->assertEquals(true, $database->createAttribute('indexes', 'boolean', Database::VAR_BOOLEAN, 0, true));
+        $this->assertEquals(true, $database->createAttribute('indexes', Attribute::string(key: 'string', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', Attribute::string(key: 'order', size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', Attribute::integer(key: 'integer', required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', Attribute::double(key: 'float', required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', Attribute::boolean(key: 'boolean', required: true)));
 
         // Indexes
-        $this->assertEquals(true, $database->createIndex('indexes', 'index1', Database::INDEX_KEY, ['string', 'integer'], [128], [Database::ORDER_ASC]));
-        $this->assertEquals(true, $database->createIndex('indexes', 'index2', Database::INDEX_KEY, ['float', 'integer'], [], [Database::ORDER_ASC, Database::ORDER_DESC]));
-        $this->assertEquals(true, $database->createIndex('indexes', 'index3', Database::INDEX_KEY, ['integer', 'boolean'], [], [Database::ORDER_ASC, Database::ORDER_DESC, Database::ORDER_DESC]));
-        $this->assertEquals(true, $database->createIndex('indexes', 'index4', Database::INDEX_UNIQUE, ['string'], [128], [Database::ORDER_ASC]));
-        $this->assertEquals(true, $database->createIndex('indexes', 'index5', Database::INDEX_UNIQUE, ['$id', 'string'], [128], [Database::ORDER_ASC]));
-        $this->assertEquals(true, $database->createIndex('indexes', 'order', Database::INDEX_UNIQUE, ['order'], [128], [Database::ORDER_ASC]));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::key(key: 'index1', attributes: ['string', 'integer'], lengths: [128], orders: [Order::Asc])));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::key(key: 'index2', attributes: ['float', 'integer'], orders: [Order::Asc, Order::Desc])));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::key(key: 'index3', attributes: ['integer', 'boolean'], orders: [Order::Asc, Order::Desc, Order::Desc])));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::unique(key: 'index4', attributes: ['string'], lengths: [128], orders: [Order::Asc])));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::unique(key: 'index5', attributes: ['$id', 'string'], lengths: [128], orders: [Order::Asc])));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::unique(key: 'order', attributes: ['order'], lengths: [128], orders: [Order::Asc])));
 
         $collection = $database->getCollection('indexes');
-        $this->assertCount(6, $collection->getAttribute('indexes'));
+        $this->assertCount(6, $collection->indexes);
 
         // Delete Indexes
         $this->assertEquals(true, $database->deleteIndex('indexes', 'index1'));
@@ -86,546 +89,169 @@ public function testCreateDeleteIndex(): void
         $this->assertEquals(true, $database->deleteIndex('indexes', 'order'));
 
         $collection = $database->getCollection('indexes');
-        $this->assertCount(0, $collection->getAttribute('indexes'));
+        $this->assertCount(0, $collection->indexes);
 
         // Test non-shared tables duplicates throw duplicate
-        $database->createIndex('indexes', 'duplicate', Database::INDEX_KEY, ['string', 'boolean'], [128], [Database::ORDER_ASC]);
+        $database->createIndex('indexes', Index::key(key: 'duplicate', attributes: ['string', 'boolean'], lengths: [128], orders: [Order::Asc]));
         try {
-            $database->createIndex('indexes', 'duplicate', Database::INDEX_KEY, ['string', 'boolean'], [128], [Database::ORDER_ASC]);
+            $database->createIndex('indexes', Index::key(key: 'duplicate', attributes: ['string', 'boolean'], lengths: [128], orders: [Order::Asc]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
             $this->assertInstanceOf(DuplicateException::class, $e);
         }
 
         // Test delete index when index does not exist
-        $this->assertEquals(true, $database->createIndex('indexes', 'index1', Database::INDEX_KEY, ['string', 'integer'], [128], [Database::ORDER_ASC]));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::key(key: 'index1', attributes: ['string', 'integer'], lengths: [128], orders: [Order::Asc])));
         $this->assertEquals(true, $this->deleteIndex('indexes', 'index1'));
         $this->assertEquals(true, $database->deleteIndex('indexes', 'index1'));
 
         // Test delete index when attribute does not exist
-        $this->assertEquals(true, $database->createIndex('indexes', 'index1', Database::INDEX_KEY, ['string', 'integer'], [128], [Database::ORDER_ASC]));
+        $this->assertEquals(true, $database->createIndex('indexes', Index::key(key: 'index1', attributes: ['string', 'integer'], lengths: [128], orders: [Order::Asc])));
         $this->assertEquals(true, $database->deleteAttribute('indexes', 'string'));
         $this->assertEquals(true, $database->deleteIndex('indexes', 'index1'));
 
         $database->deleteCollection('indexes');
     }
 
-
-
-    /**
-     * @throws Exception|Throwable
-     */
-    public function testIndexValidation(): void
+    public function testIndexLengthZero(): void
     {
-        $attributes = [
-            new Document([
-                '$id' => ID::custom('title1'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('title2'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 500,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ];
-
-        $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['title1', 'title2'],
-                'lengths' => [701,50],
-                'orders' => [],
-            ]),
-        ];
-
-        $collection = new Document([
-            '$id' => ID::custom('index_length'),
-            'name' => 'test',
-            'attributes' => $attributes,
-            'indexes' => $indexes
-        ]);
-
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $validator = new Index(
-            $attributes,
-            $indexes,
-            $database->getAdapter()->getMaxIndexLength(),
-            $database->getAdapter()->getInternalIndexesKeys(),
-            $database->getAdapter()->getSupportForIndexArray(),
-            $database->getAdapter()->getSupportForSpatialIndexNull(),
-            $database->getAdapter()->getSupportForSpatialIndexOrder(),
-            $database->getAdapter()->getSupportForVectors(),
-            $database->getAdapter()->getSupportForAttributes(),
-            $database->getAdapter()->getSupportForMultipleFulltextIndexes(),
-            $database->getAdapter()->getSupportForIdenticalIndexes(),
-            $database->getAdapter()->getSupportForObject(),
-            $database->getAdapter()->getSupportForTrigramIndex(),
-            $database->getAdapter()->getSupportForSpatialAttributes(),
-            $database->getAdapter()->getSupportForIndex(),
-            $database->getAdapter()->getSupportForUniqueIndex(),
-            $database->getAdapter()->getSupportForFulltextIndex()
-        );
-        if ($database->getAdapter()->getSupportForIdenticalIndexes()) {
-            $errorMessage = 'Index length 701 is larger than the size for title1: 700"';
-            $this->assertFalse($validator->isValid($indexes[0]));
-            $this->assertEquals($errorMessage, $validator->getDescription());
-            try {
-                $database->createCollection($collection->getId(), $attributes, $indexes, [
-                    Permission::read(Role::any()),
-                    Permission::create(Role::any()),
-                ]);
-                $this->fail('Failed to throw exception');
-            } catch (Exception $e) {
-                $this->assertEquals($errorMessage, $e->getMessage());
-            }
-        }
-
-        $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['title1', 'title2'],
-                'lengths' => [700], // 700, 500 (length(title2))
-                'orders' => [],
-            ]),
-        ];
-
-        $collection->setAttribute('indexes', $indexes);
-
-        if ($database->getAdapter()->getSupportForAttributes() && $database->getAdapter()->getMaxIndexLength() > 0) {
-            $errorMessage = 'Index length is longer than the maximum: ' . $database->getAdapter()->getMaxIndexLength();
-            $this->assertFalse($validator->isValid($indexes[0]));
-            $this->assertEquals($errorMessage, $validator->getDescription());
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
 
-            try {
-                $database->createCollection($collection->getId(), $attributes, $indexes);
-                $this->fail('Failed to throw exception');
-            } catch (Exception $e) {
-                $this->assertEquals($errorMessage, $e->getMessage());
-            }
+            return;
         }
 
-        $attributes[] = new Document([
-            '$id' => ID::custom('integer'),
-            'type' => Database::VAR_INTEGER,
-            'format' => '',
-            'size' => 10000,
-            'signed' => true,
-            'required' => false,
-            'default' => null,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_FULLTEXT,
-                'attributes' => ['title1', 'integer'],
-                'lengths' => [],
-                'orders' => [],
-            ]),
-        ];
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
-        $collection = new Document([
-            '$id' => ID::custom('index_length'),
-            'name' => 'test',
-            'attributes' => $attributes,
-            'indexes' => $indexes
-        ]);
-
-        // not using $indexes[0] as the index validator skips indexes with same id
-        $newIndex = new Document([
-            '$id' => ID::custom('newIndex1'),
-            'type' => Database::INDEX_FULLTEXT,
-            'attributes' => ['title1', 'integer'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
-
-        $validator = new Index(
-            $attributes,
-            $indexes,
-            $database->getAdapter()->getMaxIndexLength(),
-            $database->getAdapter()->getInternalIndexesKeys(),
-            $database->getAdapter()->getSupportForIndexArray(),
-            $database->getAdapter()->getSupportForSpatialIndexNull(),
-            $database->getAdapter()->getSupportForSpatialIndexOrder(),
-            $database->getAdapter()->getSupportForVectors(),
-            $database->getAdapter()->getSupportForAttributes(),
-            $database->getAdapter()->getSupportForMultipleFulltextIndexes(),
-            $database->getAdapter()->getSupportForIdenticalIndexes(),
-            $database->getAdapter()->getSupportForObject(),
-            $database->getAdapter()->getSupportForTrigramIndex(),
-            $database->getAdapter()->getSupportForSpatialAttributes(),
-            $database->getAdapter()->getSupportForIndex(),
-            $database->getAdapter()->getSupportForUniqueIndex(),
-            $database->getAdapter()->getSupportForFulltextIndex()
-        );
-
-        $this->assertFalse($validator->isValid($newIndex));
-
-        if (!$database->getAdapter()->getSupportForFulltextIndex()) {
-            $this->assertEquals('Fulltext index is not supported', $validator->getDescription());
-        } elseif (!$database->getAdapter()->getSupportForMultipleFulltextIndexes()) {
-            $this->assertEquals('There is already a fulltext index in the collection', $validator->getDescription());
-        } elseif ($database->getAdapter()->getSupportForAttributes()) {
-            $this->assertEquals('Attribute "integer" cannot be part of a fulltext index, must be of type string', $validator->getDescription());
-        }
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'title1', size: $database->getAdapter()->getMaxIndexLength() + 300, required: true));
 
         try {
-            $database->createCollection($collection->getId(), $attributes, $indexes);
-            if ($database->getAdapter()->getSupportForAttributes()) {
-                $this->fail('Failed to throw exception');
-            }
-        } catch (Exception $e) {
-            if (!$database->getAdapter()->getSupportForFulltextIndex()) {
-                $this->assertEquals('Fulltext index is not supported', $e->getMessage());
-            } else {
-                $this->assertEquals('Attribute "integer" cannot be part of a fulltext index, must be of type string', $e->getMessage());
-            }
+            $database->createIndex(__FUNCTION__, Index::key(key: 'index_title1', attributes: ['title1'], lengths: [0]));
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
         }
 
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'title2', size: 100, required: true));
+        $database->createIndex(__FUNCTION__, Index::key(key: 'index_title2', attributes: ['title2'], lengths: [0]));
 
-        $indexes = [
-            new Document([
-                '$id' => ID::custom('index_negative_length'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['title1'],
-                'lengths' => [-1],
-                'orders' => [],
-            ]),
-        ];
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $errorMessage = 'Negative index length provided for title1';
-            $this->assertFalse($validator->isValid($indexes[0]));
-            $this->assertEquals($errorMessage, $validator->getDescription());
-
-            try {
-                $database->createCollection(ID::unique(), $attributes, $indexes);
-                $this->fail('Failed to throw exception');
-            } catch (Exception $e) {
-                $this->assertEquals($errorMessage, $e->getMessage());
-            }
-
-            $indexes = [
-                new Document([
-                    '$id' => ID::custom('index_extra_lengths'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => ['title1', 'title2'],
-                    'lengths' => [100, 100, 100],
-                    'orders' => [],
-                ]),
-            ];
-            $errorMessage = 'Invalid index lengths. Count of lengths must be equal or less than the number of attributes.';
-            $this->assertFalse($validator->isValid($indexes[0]));
-            $this->assertEquals($errorMessage, $validator->getDescription());
-
-            try {
-                $database->createCollection(ID::unique(), $attributes, $indexes);
-                $this->fail('Failed to throw exception');
-            } catch (Exception $e) {
-                $this->assertEquals($errorMessage, $e->getMessage());
-            }
-        }
-    }
-
-    public function testCreateCollectionWithIndexOnSequence(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForIndex()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        try {
+            $database->updateAttribute(__FUNCTION__, 'title2', ColumnType::String->value, $database->getAdapter()->getMaxIndexLength() + 300, true);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
         }
-
-        $collection = $database->createCollection('sequenceIndexes', [
-            new Document([
-                '$id' => ID::custom('username'),
-                'type' => Database::VAR_STRING,
-                'size' => 128,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('email'),
-                'type' => Database::VAR_STRING,
-                'size' => 128,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [
-            new Document([
-                '$id' => ID::custom('_index 123'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['username', '$sequence'],
-                'lengths' => [],
-                'orders' => [Database::ORDER_ASC, Database::ORDER_DESC],
-            ]),
-            new Document([
-                '$id' => ID::custom('_index 456'),
-                'type' => Database::INDEX_UNIQUE,
-                'attributes' => ['email', '$sequence'],
-                'lengths' => [],
-                'orders' => [Database::ORDER_ASC, Database::ORDER_DESC],
-            ]),
-        ]);
-
-        $indexes = $collection->getAttribute('indexes');
-        $this->assertCount(2, $indexes);
-        $this->assertEquals('_index 123', $indexes[0]->getId());
-        $this->assertEquals(['username', '$sequence'], $indexes[0]->getAttribute('attributes'));
-        $this->assertEquals('_index 456', $indexes[1]->getId());
-        $this->assertEquals(['email', '$sequence'], $indexes[1]->getAttribute('attributes'));
-
-        $database->createDocument('sequenceIndexes', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'username' => 'chester',
-            'email' => 'chester@example.com',
-        ]));
-
-        $documents = $database->find('sequenceIndexes', [
-            Query::equal('username', ['chester']),
-            Query::orderDesc('$sequence'),
-        ]);
-
-        $this->assertCount(1, $documents);
-        $this->assertEquals('chester', $documents[0]->getAttribute('username'));
-
-        /**
-         * $sequence is unique on its own, so a unique index containing it never
-         * conflicts. A duplicate here would mean the adapter built the index
-         * without the $sequence column.
-         */
-        $database->createDocument('sequenceIndexes', new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'username' => 'chester',
-            'email' => 'chester@example.com',
-        ]));
-
-        $this->assertCount(2, $database->find('sequenceIndexes', [
-            Query::equal('email', ['chester@example.com']),
-        ]));
-
-        $database->deleteCollection('sequenceIndexes');
     }
 
-    public function testCreateIndexOnSequence(): void
+    /**
+     * An index length may not exceed the size of the attribute it covers. This is
+     * a different bound from the adapter's maximum index length that
+     * {@see self::testIndexLengthZero} covers: 701 is well under the maximum, and
+     * only oversized relative to title1's own 700.
+     *
+     * Ported from main's testIndexValidation, which drove Validator\Index
+     * directly. Going through createIndex() proves the validator is actually
+     * consulted on the path a caller takes, which a direct construction cannot.
+     */
+    public function testIndexLengthExceedsAttributeSize(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForIndex()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)
+            || ! $database->getAdapter()->supports(Capability::IdenticalIndexes)) {
             $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection(__FUNCTION__);
-
-        $this->assertTrue($database->createAttribute(__FUNCTION__, 'username', Database::VAR_STRING, 128, false));
-        $this->assertTrue($database->createAttribute(__FUNCTION__, 'email', Database::VAR_STRING, 128, false));
-
-        $this->assertTrue($database->createIndex(
-            __FUNCTION__,
-            '_index 123',
-            Database::INDEX_KEY,
-            ['username', '$sequence'],
-            [],
-            [Database::ORDER_ASC, Database::ORDER_DESC]
-        ));
-
-        $this->assertTrue($database->createIndex(
-            __FUNCTION__,
-            '_index 456',
-            Database::INDEX_UNIQUE,
-            ['email', '$sequence'],
-            [],
-            [Database::ORDER_ASC, Database::ORDER_DESC]
-        ));
-
-        $indexes = $database->getCollection(__FUNCTION__)->getAttribute('indexes');
-        $this->assertCount(2, $indexes);
-        $this->assertEquals('_index 123', $indexes[0]->getId());
-        $this->assertEquals(['username', '$sequence'], $indexes[0]->getAttribute('attributes'));
-        $this->assertEquals('_index 456', $indexes[1]->getId());
-        $this->assertEquals(['email', '$sequence'], $indexes[1]->getAttribute('attributes'));
-
-        $database->createDocument(__FUNCTION__, new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'username' => 'chester',
-            'email' => 'chester@example.com',
-        ]));
-
-        $documents = $database->find(__FUNCTION__, [
-            Query::equal('username', ['chester']),
-            Query::orderDesc('$sequence'),
-        ]);
-
-        $this->assertCount(1, $documents);
-        $this->assertEquals('chester', $documents[0]->getAttribute('username'));
 
-        /**
-         * $sequence is unique on its own, so a unique index containing it never
-         * conflicts. A duplicate here would mean the adapter built the index
-         * without the $sequence column.
-         */
-        $database->createDocument(__FUNCTION__, new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'username' => 'chester',
-            'email' => 'chester@example.com',
-        ]));
-
-        $this->assertCount(2, $database->find(__FUNCTION__, [
-            Query::equal('email', ['chester@example.com']),
-        ]));
-
-        $database->deleteCollection(__FUNCTION__);
-    }
-
-    public function testIndexLengthZero(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
             return;
         }
 
-        $database->createCollection(__FUNCTION__);
-
-        $database->createAttribute(__FUNCTION__, 'title1', Database::VAR_STRING, $database->getAdapter()->getMaxIndexLength() + 300, true);
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'title1', size: 700, required: false));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'title2', size: 500, required: false));
 
         try {
-            $database->createIndex(__FUNCTION__, 'index_title1', Database::INDEX_KEY, ['title1'], [0]);
+            $database->createIndex(__FUNCTION__, Index::key(key: 'index1', attributes: ['title1', 'title2'], lengths: [701, 50]));
             $this->fail('Failed to throw exception');
         } catch (Throwable $e) {
-            $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
+            $this->assertEquals('Index length 701 is larger than the size for title1: 700"', $e->getMessage());
         }
 
-
-        $database->createAttribute(__FUNCTION__, 'title2', Database::VAR_STRING, 100, true);
-        $database->createIndex(__FUNCTION__, 'index_title2', Database::INDEX_KEY, ['title2'], [0]);
-
-        try {
-            $database->updateAttribute(__FUNCTION__, 'title2', Database::VAR_STRING, $database->getAdapter()->getMaxIndexLength() + 300, true);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertEquals('Index length is longer than the maximum: '.$database->getAdapter()->getMaxIndexLength(), $e->getMessage());
-        }
+        $database->deleteCollection(__FUNCTION__);
     }
 
     public function testRenameIndex(): void
     {
         $database = $this->getDatabase();
+        $collection = $this->getNumbersCollection();
 
-        $numbers = $database->createCollection('numbers');
-        $database->createAttribute('numbers', 'verbose', Database::VAR_STRING, 128, true);
-        $database->createAttribute('numbers', 'symbol', Database::VAR_INTEGER, 0, true);
+        $numbers = $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'verbose', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'symbol', required: true));
 
-        $database->createIndex('numbers', 'index1', Database::INDEX_KEY, ['verbose'], [128], [Database::ORDER_ASC]);
-        $database->createIndex('numbers', 'index2', Database::INDEX_KEY, ['symbol'], [0], [Database::ORDER_ASC]);
+        $database->createIndex($collection, Index::key(key: 'index1', attributes: ['verbose'], lengths: [128], orders: [Order::Asc]));
+        $database->createIndex($collection, Index::key(key: 'index2', attributes: ['symbol'], lengths: [0], orders: [Order::Asc]));
 
-        $index = $database->renameIndex('numbers', 'index1', 'index3');
+        $index = $database->renameIndex($collection, 'index1', 'index3');
 
         $this->assertTrue($index);
 
-        $numbers = $database->getCollection('numbers');
+        $numbers = $database->getCollection($collection);
 
-        $this->assertEquals('index2', $numbers->getAttribute('indexes')[1]['$id']);
-        $this->assertEquals('index3', $numbers->getAttribute('indexes')[0]['$id']);
-        $this->assertCount(2, $numbers->getAttribute('indexes'));
+        $this->assertEquals('index2', $numbers->indexes[1]['$id']);
+        $this->assertEquals('index3', $numbers->indexes[0]['$id']);
+        $this->assertCount(2, $numbers->indexes);
     }
 
+    private static string $numbersCollection = '';
 
-    /**
-    * @depends testRenameIndex
-    * @expectedException Exception
-    */
-    public function testRenameIndexMissing(): void
-    {
-        $database = $this->getDatabase();
-        $this->expectExceptionMessage('Index not found');
-        $index = $database->renameIndex('numbers', 'index1', 'index4');
-    }
-
-    /**
-    * @depends testRenameIndex
-    * @expectedException Exception
-    */
-    public function testRenameIndexExisting(): void
+    protected function getNumbersCollection(): string
     {
-        $database = $this->getDatabase();
-        $this->expectExceptionMessage('Index name already used');
-        $index = $database->renameIndex('numbers', 'index3', 'index2');
+        if (self::$numbersCollection === '') {
+            self::$numbersCollection = 'numbers_' . uniqid();
+        }
+        return self::$numbersCollection;
     }
 
+    private static bool $renameIndexFixtureInit = false;
 
-    public function testExceptionIndexLimit(): void
+    protected function initRenameIndexFixture(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection('indexLimit');
-
-        // add unique attributes for indexing
-        for ($i = 0; $i < 64; $i++) {
-            $this->assertEquals(true, $database->createAttribute('indexLimit', "test{$i}", Database::VAR_STRING, 16, true));
+        if (self::$renameIndexFixtureInit) {
+            return;
         }
 
-        // Testing for indexLimit
-        // Add up to the limit, then check if the next index throws IndexLimitException
-        for ($i = 0; $i < ($this->getDatabase()->getLimitForIndexes()); $i++) {
-            $this->assertEquals(true, $database->createIndex('indexLimit', "index{$i}", Database::INDEX_KEY, ["test{$i}"], [16]));
-        }
-        $this->expectException(LimitException::class);
-        $this->assertEquals(false, $database->createIndex('indexLimit', "index64", Database::INDEX_KEY, ["test64"], [16]));
+        $database = $this->getDatabase();
+        $collection = $this->getNumbersCollection();
+
+        $database->createCollection(new Collection(id: $collection));
+        $database->createAttribute($collection, Attribute::string(key: 'verbose', size: 128, required: true));
+        $database->createAttribute($collection, Attribute::integer(key: 'symbol', required: true));
+        $database->createIndex($collection, Index::key(key: 'index1', attributes: ['verbose'], lengths: [128], orders: [Order::Asc]));
+        $database->createIndex($collection, Index::key(key: 'index2', attributes: ['symbol'], lengths: [0], orders: [Order::Asc]));
+        $database->renameIndex($collection, 'index1', 'index3');
 
-        $database->deleteCollection('indexLimit');
+        self::$renameIndexFixtureInit = true;
     }
 
     public function testListDocumentSearch(): void
     {
-        $fulltextSupport = $this->getDatabase()->getAdapter()->getSupportForFulltextIndex();
-        if (!$fulltextSupport) {
+        $fulltextSupport = $this->getDatabase()->getAdapter()->supports(Capability::Fulltext);
+        if (! $fulltextSupport) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
+        $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createIndex('documents', 'string', Database::INDEX_FULLTEXT, ['string']);
-        $database->createDocument('documents', new Document([
+        $database->createIndex($this->getDocumentsCollection(), Index::fullText(key: 'string', attributes: ['string']));
+        $database->createDocument($this->getDocumentsCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -647,193 +273,56 @@ public function testListDocumentSearch(): void
         /**
          * Allow reserved keywords for search
          */
-        $documents = $database->find('documents', [
+        $documents = $database->find($this->getDocumentsCollection(), [
             Query::search('string', '*test+alias@email-provider.com'),
         ]);
 
         $this->assertEquals(1, count($documents));
     }
 
-    public function testMaxQueriesValues(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $max = $database->getMaxQueryValues();
-
-        $database->setMaxQueryValues(5);
-
-        try {
-            $database->find(
-                'documents',
-                [Query::equal('$id', [1, 2, 3, 4, 5, 6])]
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertTrue($e instanceof QueryException);
-            $this->assertEquals('Invalid query: Query on attribute has greater than 5 values: $id', $e->getMessage());
-        }
-
-        $database->setMaxQueryValues($max);
-    }
-
     public function testEmptySearch(): void
     {
-        $fulltextSupport = $this->getDatabase()->getAdapter()->getSupportForFulltextIndex();
-        if (!$fulltextSupport) {
+        $fulltextSupport = $this->getDatabase()->getAdapter()->supports(Capability::Fulltext);
+        if (! $fulltextSupport) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
+        $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $documents = $database->find('documents', [
+        // Create fulltext index if it doesn't exist (was created by testListDocumentSearch in sequential mode)
+        try {
+            $database->createIndex($this->getDocumentsCollection(), Index::fullText(key: 'string', attributes: ['string']));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        $documents = $database->find($this->getDocumentsCollection(), [
             Query::search('string', ''),
         ]);
         $this->assertEquals(0, count($documents));
 
-        $documents = $database->find('documents', [
+        $documents = $database->find($this->getDocumentsCollection(), [
             Query::search('string', '*'),
         ]);
         $this->assertEquals(0, count($documents));
 
-        $documents = $database->find('documents', [
+        $documents = $database->find($this->getDocumentsCollection(), [
             Query::search('string', '<>'),
         ]);
         $this->assertEquals(0, count($documents));
     }
 
-    public function testMultipleFulltextIndexValidation(): void
-    {
-
-        $fulltextSupport = $this->getDatabase()->getAdapter()->getSupportForFulltextIndex();
-        if (!$fulltextSupport) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $collectionId = 'multiple_fulltext_test';
-        try {
-            $database->createCollection($collectionId);
-
-            $database->createAttribute($collectionId, 'title', Database::VAR_STRING, 256, false);
-            $database->createAttribute($collectionId, 'content', Database::VAR_STRING, 256, false);
-            $database->createIndex($collectionId, 'fulltext_title', Database::INDEX_FULLTEXT, ['title']);
-
-            $supportsMultipleFulltext = $database->getAdapter()->getSupportForMultipleFulltextIndexes();
-
-            // Try to add second fulltext index
-            try {
-                $database->createIndex($collectionId, 'fulltext_content', Database::INDEX_FULLTEXT, ['content']);
-
-                if ($supportsMultipleFulltext) {
-                    $this->assertTrue(true, 'Multiple fulltext indexes are supported and second index was created successfully');
-                } else {
-                    $this->fail('Expected exception when creating second fulltext index, but none was thrown');
-                }
-            } catch (Throwable $e) {
-                if (!$supportsMultipleFulltext) {
-                    $this->assertTrue(true, 'Multiple fulltext indexes are not supported and exception was thrown as expected');
-                } else {
-                    $this->fail('Unexpected exception when creating second fulltext index: ' . $e->getMessage());
-                }
-            }
-
-        } finally {
-            // Clean up
-            $database->deleteCollection($collectionId);
-        }
-    }
-
-    public function testIdenticalIndexValidation(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $collectionId = 'identical_index_test';
-
-        try {
-            $database->createCollection($collectionId);
-
-            $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 256, false);
-            $database->createAttribute($collectionId, 'age', Database::VAR_INTEGER, 8, false);
-
-            $database->createIndex($collectionId, 'index1', Database::INDEX_KEY, ['name', 'age'], [], [Database::ORDER_ASC, Database::ORDER_DESC]);
-
-            $supportsIdenticalIndexes = $database->getAdapter()->getSupportForIdenticalIndexes();
-
-            // Try to add identical index (failure)
-            try {
-                $database->createIndex($collectionId, 'index2', Database::INDEX_KEY, ['name', 'age'], [], [Database::ORDER_ASC, Database::ORDER_DESC]);
-                if ($supportsIdenticalIndexes) {
-                    $this->assertTrue(true, 'Identical indexes are supported and second index was created successfully');
-                } else {
-                    $this->fail('Expected exception but got none');
-                }
-
-            } catch (Throwable $e) {
-                if (!$supportsIdenticalIndexes) {
-                    $this->assertTrue(true, 'Identical indexes are not supported and exception was thrown as expected');
-                } else {
-                    $this->fail('Unexpected exception when creating identical index: ' . $e->getMessage());
-                }
-
-            }
-
-            // Test with different attributes order - faliure
-            try {
-                $database->createIndex($collectionId, 'index3', Database::INDEX_KEY, ['age', 'name'], [], [ Database::ORDER_ASC, Database::ORDER_DESC]);
-                $this->assertTrue(true, 'Index with different attributes was created successfully');
-            } catch (Throwable $e) {
-                if (!$supportsIdenticalIndexes) {
-                    $this->assertTrue(true, 'Identical indexes are not supported and exception was thrown as expected');
-                } else {
-                    $this->fail('Unexpected exception when creating identical index: ' . $e->getMessage());
-                }
-            }
-
-            // Test with different orders  order - faliure
-            try {
-                $database->createIndex($collectionId, 'index4', Database::INDEX_KEY, ['age', 'name'], [], [ Database::ORDER_DESC, Database::ORDER_ASC]);
-                $this->assertTrue(true, 'Index with different attributes was created successfully');
-            } catch (Throwable $e) {
-                if (!$supportsIdenticalIndexes) {
-                    $this->assertTrue(true, 'Identical indexes are not supported and exception was thrown as expected');
-                } else {
-                    $this->fail('Unexpected exception when creating identical index: ' . $e->getMessage());
-                }
-            }
-
-            // Test with different attributes - success
-            try {
-                $database->createIndex($collectionId, 'index5', Database::INDEX_KEY, ['name'], [], [Database::ORDER_ASC]);
-                $this->assertTrue(true, 'Index with different attributes was created successfully');
-            } catch (Throwable $e) {
-                $this->fail('Unexpected exception when creating index with different attributes: ' . $e->getMessage());
-            }
-
-            // Test with different orders - success
-            try {
-                $database->createIndex($collectionId, 'index6', Database::INDEX_KEY, ['name', 'age'], [], [Database::ORDER_ASC]);
-                $this->assertTrue(true, 'Index with different orders was created successfully');
-            } catch (Throwable $e) {
-                $this->fail('Unexpected exception when creating index with different orders: ' . $e->getMessage());
-            }
-        } finally {
-            // Clean up
-            $database->deleteCollection($collectionId);
-        }
-    }
-
     public function testTrigramIndex(): void
     {
-        $trigramSupport = $this->getDatabase()->getAdapter()->getSupportForTrigramIndex();
-        if (!$trigramSupport) {
+        $trigramSupport = $this->getDatabase()->getAdapter()->supports(Capability::TrigramIndex);
+        if (! $trigramSupport) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -842,26 +331,26 @@ public function testTrigramIndex(): void
 
         $collectionId = 'trigram_test';
         try {
-            $database->createCollection($collectionId);
+            $database->createCollection(new Collection(id: $collectionId));
 
-            $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 256, false);
-            $database->createAttribute($collectionId, 'description', Database::VAR_STRING, 512, false);
+            $database->createAttribute($collectionId, Attribute::string(key: 'name', size: 256));
+            $database->createAttribute($collectionId, Attribute::string(key: 'description', size: 512));
 
             // Create trigram index on name attribute
-            $this->assertEquals(true, $database->createIndex($collectionId, 'trigram_name', Database::INDEX_TRIGRAM, ['name']));
+            $this->assertEquals(true, $database->createIndex($collectionId, Index::trigram(key: 'trigram_name', attributes: ['name'])));
 
             $collection = $database->getCollection($collectionId);
-            $indexes = $collection->getAttribute('indexes');
+            $indexes = $collection->indexes;
             $this->assertCount(1, $indexes);
             $this->assertEquals('trigram_name', $indexes[0]['$id']);
-            $this->assertEquals(Database::INDEX_TRIGRAM, $indexes[0]['type']);
+            $this->assertEquals(IndexType::Trigram->value, $indexes[0]['type']);
             $this->assertEquals(['name'], $indexes[0]['attributes']);
 
             // Create another trigram index on description
-            $this->assertEquals(true, $database->createIndex($collectionId, 'trigram_description', Database::INDEX_TRIGRAM, ['description']));
+            $this->assertEquals(true, $database->createIndex($collectionId, Index::trigram(key: 'trigram_description', attributes: ['description'])));
 
             $collection = $database->getCollection($collectionId);
-            $indexes = $collection->getAttribute('indexes');
+            $indexes = $collection->indexes;
             $this->assertCount(2, $indexes);
 
             // Test that trigram index can be deleted
@@ -869,7 +358,7 @@ public function testTrigramIndex(): void
             $this->assertEquals(true, $database->deleteIndex($collectionId, 'trigram_description'));
 
             $collection = $database->getCollection($collectionId);
-            $indexes = $collection->getAttribute('indexes');
+            $indexes = $collection->indexes;
             $this->assertCount(0, $indexes);
 
         } finally {
@@ -878,119 +367,39 @@ public function testTrigramIndex(): void
         }
     }
 
-    public function testTrigramIndexValidation(): void
-    {
-        $trigramSupport = $this->getDatabase()->getAdapter()->getSupportForTrigramIndex();
-        if (!$trigramSupport) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        $collectionId = 'trigram_validation_test';
-        try {
-            $database->createCollection($collectionId);
-
-            $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 256, false);
-            $database->createAttribute($collectionId, 'description', Database::VAR_STRING, 412, false);
-            $database->createAttribute($collectionId, 'age', Database::VAR_INTEGER, 8, false);
-
-            // Test: Trigram index on non-string attribute should fail
-            try {
-                $database->createIndex($collectionId, 'trigram_invalid', Database::INDEX_TRIGRAM, ['age']);
-                $this->fail('Expected exception when creating trigram index on non-string attribute');
-            } catch (Exception $e) {
-                $this->assertStringContainsString('Trigram index can only be created on string type attributes', $e->getMessage());
-            }
-
-            // Test: Trigram index with multiple string attributes should succeed
-            $this->assertEquals(true, $database->createIndex($collectionId, 'trigram_multi', Database::INDEX_TRIGRAM, ['name', 'description']));
-
-            $collection = $database->getCollection($collectionId);
-            $indexes = $collection->getAttribute('indexes');
-            $trigramMultiIndex = null;
-            foreach ($indexes as $idx) {
-                if ($idx['$id'] === 'trigram_multi') {
-                    $trigramMultiIndex = $idx;
-                    break;
-                }
-            }
-            $this->assertNotNull($trigramMultiIndex);
-            $this->assertEquals(Database::INDEX_TRIGRAM, $trigramMultiIndex['type']);
-            $this->assertEquals(['name', 'description'], $trigramMultiIndex['attributes']);
-
-            // Test: Trigram index with mixed string and non-string attributes should fail
-            try {
-                $database->createIndex($collectionId, 'trigram_mixed', Database::INDEX_TRIGRAM, ['name', 'age']);
-                $this->fail('Expected exception when creating trigram index with mixed attribute types');
-            } catch (Exception $e) {
-                $this->assertStringContainsString('Trigram index can only be created on string type attributes', $e->getMessage());
-            }
-
-            // Test: Trigram index with orders should fail
-            try {
-                $database->createIndex($collectionId, 'trigram_order', Database::INDEX_TRIGRAM, ['name'], [], [Database::ORDER_ASC]);
-                $this->fail('Expected exception when creating trigram index with orders');
-            } catch (Exception $e) {
-                $this->assertStringContainsString('Trigram indexes do not support orders or lengths', $e->getMessage());
-            }
-
-            // Test: Trigram index with lengths should fail
-            try {
-                $database->createIndex($collectionId, 'trigram_length', Database::INDEX_TRIGRAM, ['name'], [128]);
-                $this->fail('Expected exception when creating trigram index with lengths');
-            } catch (Exception $e) {
-                $this->assertStringContainsString('Trigram indexes do not support orders or lengths', $e->getMessage());
-            }
-
-        } finally {
-            // Clean up
-            $database->deleteCollection($collectionId);
-        }
-    }
-
     public function testTTLIndexes(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForTTLIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::TTLIndexes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_ttl');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
-        $database->createAttribute($col, 'expiresAt', Database::VAR_DATETIME, 0, false);
+        $database->createAttribute($col, Attribute::datetime(key: 'expiresAt', filters: ['datetime']));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_valid',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                3600 // 1 hour TTL
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_valid', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 3600))
         );
 
         $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(1, $indexes);
         $ttlIndex = $indexes[0];
         $this->assertEquals('idx_ttl_valid', $ttlIndex->getId());
-        $this->assertEquals(Database::INDEX_TTL, $ttlIndex->getAttribute('type'));
+        $this->assertEquals(IndexType::Ttl->value, $ttlIndex->getAttribute('type'));
         $this->assertEquals(3600, $ttlIndex->getAttribute('ttl'));
 
         $now = new \DateTime();
@@ -1013,49 +422,25 @@ public function testTTLIndexes(): void
                 '$id' => 'doc3',
                 '$permissions' => $permissions,
                 'expiresAt' => $past->format(\DateTime::ATOM),
-            ])
+            ]),
         ]);
 
         $this->assertTrue($database->deleteIndex($col, 'idx_ttl_valid'));
 
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_min',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                1 // Minimum TTL
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_min', attributes: ['expiresAt'], orders: [Order::Asc]))
         );
 
         $col2 = uniqid('sl_ttl_collection');
 
-        $expiresAtAttr = new Document([
-            '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
-            'size' => 0,
-            'signed' => false,
-            'required' => false,
-            'default' => null,
-            'array' => false,
-            'filters' => ['datetime'],
-        ]);
+        $expiresAtAttr = Attribute::datetime(key: 'expiresAt', signed: false, filters: ['datetime']);
 
-        $ttlIndexDoc = new Document([
-            '$id' => ID::custom('idx_ttl_collection'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200 // 2 hours
-        ]);
+        $ttlIndexDoc = Index::ttl(key: 'idx_ttl_collection', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 7200);
 
-        $database->createCollection($col2, [$expiresAtAttr], [$ttlIndexDoc]);
+        $database->createCollection(new Collection(id: $col2, attributes: [$expiresAtAttr], indexes: [$ttlIndexDoc]));
 
         $collection2 = $database->getCollection($col2);
-        $indexes2 = $collection2->getAttribute('indexes');
+        $indexes2 = $collection2->indexes;
         $this->assertCount(1, $indexes2);
         $ttlIndex2 = $indexes2[0];
         $this->assertEquals('idx_ttl_collection', $ttlIndex2->getId());
@@ -1065,152 +450,4 @@ public function testTTLIndexes(): void
         $database->deleteCollection($col2);
     }
 
-    public function testTTLIndexDuplicatePrevention(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForTTLIndexes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $col = uniqid('sl_ttl_dup');
-        $database->createCollection($col);
-
-        $database->createAttribute($col, 'expiresAt', Database::VAR_DATETIME, 0, false);
-        $database->createAttribute($col, 'deletedAt', Database::VAR_DATETIME, 0, false);
-
-        $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_expires',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                3600 // 1 hour
-            )
-        );
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_expires_duplicate',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                7200 // 2 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                86400 // 24 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
-        $this->assertCount(1, $indexes);
-
-        $indexIds = array_map(fn ($idx) => $idx->getId(), $indexes);
-        $this->assertContains('idx_ttl_expires', $indexIds);
-        $this->assertNotContains('idx_ttl_deleted', $indexIds);
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted_duplicate',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                172800 // 48 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        $this->assertTrue($database->deleteIndex($col, 'idx_ttl_expires'));
-
-        $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                1800 // 30 minutes
-            )
-        );
-
-        $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
-        $this->assertCount(1, $indexes);
-
-        $indexIds = array_map(fn ($idx) => $idx->getId(), $indexes);
-        $this->assertNotContains('idx_ttl_expires', $indexIds);
-        $this->assertContains('idx_ttl_deleted', $indexIds);
-
-        $col3 = uniqid('sl_ttl_dup_collection');
-
-        $expiresAtAttr = new Document([
-            '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
-            'size' => 0,
-            'signed' => false,
-            'required' => false,
-            'default' => null,
-            'array' => false,
-            'filters' => ['datetime'],
-        ]);
-
-        $ttlIndex1 = new Document([
-            '$id' => ID::custom('idx_ttl_1'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 3600
-        ]);
-
-        $ttlIndex2 = new Document([
-            '$id' => ID::custom('idx_ttl_2'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200
-        ]);
-
-        try {
-            $database->createCollection($col3, [$expiresAtAttr], [$ttlIndex1, $ttlIndex2]);
-            $this->fail('Expected exception for duplicate TTL indexes in createCollection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        // Cleanup
-        $database->deleteCollection($col);
-    }
 }
diff --git a/tests/e2e/Adapter/Scopes/JoinComboTests.php b/tests/e2e/Adapter/Scopes/JoinComboTests.php
new file mode 100644
index 0000000000..d431f45582
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/JoinComboTests.php
@@ -0,0 +1,2253 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\Query;
+use Utopia\Query\Schema\IndexType;
+
+trait JoinComboTests
+{
+    public function testJoinComboLeftPublicAndInnerSecretMixedDocSec(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol, $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol, $secCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+            ]);
+
+            $this->assertSame(5, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $scores = $this->comboNumericScores($results);
+            $this->assertContains(313, $scores);
+            $this->assertContains(10, $scores);
+            $this->assertSame(false, \in_array(777, $scores, true));
+            $this->assertSame(false, \in_array(4242, $scores, true));
+
+            $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+            $this->assertContains('m1', $ids);
+            $this->assertContains('m2', $ids);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboSelfJoinPlusThirdTableAclPerAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [, , , $selfCol, $cCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $selfCol, $cCol): void {
+            $results = $database->find($selfCol, [
+                Query::join($selfCol, 'tag', 'tag', '=', 'visible'),
+                Query::join($selfCol, 'tag', 'tag', '=', 'hidden'),
+                Query::join($cCol, 'visible.$id', 'selfId', '=', 'c'),
+                Query::select(['visible.payload', 'hidden.payload', 'c.secret']),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+            $this->assertSame('open-payload', $results[0]->getAttribute('payload'));
+            $this->assertNotSame('combo-secret-alpha', $results[0]->getAttribute('payload'));
+            $this->assertSame('c-open-token', $results[0]->getAttribute('secret'));
+            $this->assertNotSame('c-combo-secret', $results[0]->getId());
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboOrderBySecretColumnLimitOffsetOracle(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol, $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol, $secCol): void {
+            $ordered = $database->find($mCol, [
+                Query::leftJoin($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::orderDesc('sec.score'),
+            ]);
+            $this->assertComboSecretsHidden($ordered);
+            $scores = $this->comboNumericScores($ordered);
+            $this->assertSame(false, \in_array(777, $scores, true));
+            $this->assertContains(313, $scores);
+            $this->assertSame($scores, $this->sortedDesc($scores));
+
+            $limited = $database->find($mCol, [
+                Query::leftJoin($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::orderDesc('sec.score'),
+                Query::limit(2),
+            ]);
+            $this->assertSame(2, \count($limited));
+            $this->assertComboSecretsHidden($limited);
+            $this->assertSame(
+                \array_slice($this->comboNumericScores($ordered), 0, 2),
+                $this->comboNumericScores($limited)
+            );
+
+            $offset = $database->find($mCol, [
+                Query::leftJoin($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::orderDesc('sec.score'),
+                Query::limit(2),
+                Query::offset(1),
+            ]);
+            $this->assertSame(2, \count($offset));
+            $this->assertComboSecretsHidden($offset);
+            $this->assertSame(
+                \array_slice($this->comboNumericScores($ordered), 1, 2),
+                $this->comboNumericScores($offset)
+            );
+
+            $foj = $database->find($mCol, [
+                Query::fullOuterJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::orderDesc('pub.score'),
+            ]);
+            $this->assertComboSecretsHidden($foj);
+            $fojScores = $this->comboNumericScores($foj);
+            $this->assertSame(4242, $fojScores[0]);
+            $this->assertContains(313, $fojScores);
+            $this->assertSame(false, \in_array(777, $fojScores, true));
+            $this->assertSame($fojScores, $this->sortedDesc($fojScores));
+
+            $fojLimited = $database->find($mCol, [
+                Query::fullOuterJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::orderDesc('pub.score'),
+                Query::limit(2),
+                Query::offset(1),
+            ]);
+            $this->assertSame(2, \count($fojLimited));
+            $this->assertComboSecretsHidden($fojLimited);
+
+            $identity = static function (Document $document): string {
+                $score = $document->getAttribute('pub.score') ?? $document->getAttribute('score');
+
+                return $document->getId().':'.(\is_numeric($score) ? (string) (int) $score : '');
+            };
+            $this->assertSame(
+                \array_slice(\array_map($identity, $foj), 1, 2),
+                \array_map($identity, $fojLimited)
+            );
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboFilterSecretWithoutProjectingSecret(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $secCol): void {
+            $results = $database->find($mCol, [
+                Query::join($secCol, '$id', 'mainId', '=', 'rev'),
+                Query::equal('rev.score', [777]),
+                Query::select(['name']),
+            ]);
+
+            $this->assertSame(0, \count($results));
+            $this->assertComboSecretsHidden($results);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboSumCountHavingExactSiblingOracle(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+        if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $secCol): void {
+            $aggregated = $database->find($mCol, [
+                Query::join($secCol, '$id', 'mainId', '=', 'rev'),
+                Query::equal('name', ['Main']),
+                Query::sum('rev.score', 'total'),
+                Query::count('*', 'cnt'),
+                Query::groupBy(['name']),
+            ]);
+
+            $this->assertSame(1, \count($aggregated));
+            $this->assertComboSecretsHidden($aggregated);
+            $total = $aggregated[0]->getAttribute('total');
+            $this->assertTrue(\is_numeric($total));
+            $this->assertSame(323, (int) $total);
+            $this->assertNotSame(1100, (int) $total);
+            $cnt = $aggregated[0]->getAttribute('cnt');
+            $this->assertTrue(\is_numeric($cnt));
+            $this->assertSame(2, (int) $cnt);
+            $this->assertNotSame(3, (int) $cnt);
+
+            $havingSum = $database->find($mCol, [
+                Query::join($secCol, '$id', 'mainId', '=', 'rev'),
+                Query::sum('rev.score', 'total'),
+                Query::count('*', 'cnt'),
+                Query::groupBy(['name']),
+                Query::having([Query::equal('total', [1100])]),
+            ]);
+            $this->assertSame(0, \count($havingSum));
+            $this->assertComboSecretsHidden($havingSum);
+
+            $havingCount = $database->find($mCol, [
+                Query::join($secCol, '$id', 'mainId', '=', 'rev'),
+                Query::sum('rev.score', 'total'),
+                Query::count('*', 'cnt'),
+                Query::groupBy(['name']),
+                Query::having([Query::equal('cnt', [3])]),
+            ]);
+            $this->assertSame(0, \count($havingCount));
+            $this->assertComboSecretsHidden($havingCount);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboCursorAfterJoinSideOrderAttribute(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol): void {
+            $full = $database->find($mCol, [
+                Query::join($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::orderAsc('pub.score'),
+            ]);
+            $this->assertSame(2, \count($full));
+            $this->assertComboSecretsHidden($full);
+            $this->assertSame([10, 313], $this->comboNumericScores($full));
+
+            $first = $database->find($mCol, [
+                Query::join($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::orderAsc('pub.score'),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($first));
+            $this->assertSame(10, $this->comboNumericScores($first)[0]);
+            $this->assertComboSecretsHidden($first);
+
+            $next = $database->find($mCol, [
+                Query::join($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::orderAsc('pub.score'),
+                Query::cursorAfter($first[0]),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($next));
+            $this->assertComboSecretsHidden($next);
+            $this->assertSame(313, $this->comboNumericScores($next)[0]);
+            $this->assertSame($full[1]->getId(), $next[0]->getId());
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboFullOuterPlusLeftThenIsNull(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol, $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol, $secCol): void {
+            $results = $database->find($mCol, [
+                Query::fullOuterJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::leftJoin($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::isNull('sec.score'),
+                Query::select(['name', 'pub.score']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $scores = $this->comboNumericScores($results);
+            $this->assertContains(4242, $scores);
+            $this->assertSame(false, \in_array(777, $scores, true));
+            $this->assertSame(false, \in_array(313, $scores, true));
+            $this->assertSame(false, \in_array(10, $scores, true));
+
+            foreach ($results as $document) {
+                $this->assertNotSame('j-combo-secret', $document->getId());
+                $pubScore = $document->getAttribute('pub.score') ?? $document->getAttribute('score');
+                if (\is_numeric($pubScore) && (int) $pubScore === 4242) {
+                    continue;
+                }
+                $secScore = $document->getAttribute('sec.score');
+                $this->assertTrue($secScore === null || $secScore === '');
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboCrossJoinEqualDoesNotCartesianExplodeSecrets(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $secCol): void {
+            $crossed = $database->find($mCol, [
+                Query::crossJoin($secCol, 'sec'),
+            ]);
+            $this->assertSame(6, \count($crossed));
+            $this->assertComboSecretsHidden($crossed);
+            $this->assertSame(false, \in_array(777, $this->comboNumericScores($crossed), true));
+
+            $equal = $database->find($mCol, [
+                Query::crossJoin($secCol, 'sec'),
+                Query::equal('sec.score', [10]),
+            ]);
+            $this->assertSame(2, \count($equal));
+            $this->assertComboSecretsHidden($equal);
+            foreach ($this->comboNumericScores($equal) as $score) {
+                $this->assertNotSame(777, $score);
+                $this->assertSame(10, $score);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboGetDocumentLeftUnmatchedAndInnerMatched(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol, $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol, $secCol): void {
+            $unmatched = $database->getDocument($mCol, 'm2', [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+            ]);
+            $this->assertSame(false, $unmatched->isEmpty());
+            $this->assertSame('m2', $unmatched->getId());
+            $this->assertComboSecretHidden($unmatched);
+            $unmatchedScore = $unmatched->getAttribute('score');
+            $this->assertTrue(\is_numeric($unmatchedScore));
+            $this->assertSame(313, (int) $unmatchedScore);
+
+            $matched = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+            ]);
+            $this->assertSame(false, $matched->isEmpty());
+            $this->assertSame('m1', $matched->getId());
+            $this->assertComboSecretHidden($matched);
+            $this->assertNotSame(777, $matched->getAttribute('score'));
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboSelectJoinPermissionsAndIdDoesNotLeak(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $secCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::select(['name', 'sec.$id', 'sec.$permissions']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            foreach ($results as $document) {
+                $this->assertNotSame('j-combo-secret', $document->getId());
+                $this->assertContains($document->getId(), ['m1', 'm2']);
+                foreach ($document->getPermissions() as $permission) {
+                    $this->assertSame(false, \str_contains($permission, 'user:combo-hidden'));
+                    $this->assertSame(false, \str_contains($permission, 'combo-secret-perm'));
+                    $this->assertSame(false, \str_contains($permission, 'j-combo-secret'));
+                }
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboChainDocSecOffThenOnHidesSecretC(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , , $selfCol, $cCol] = $this->seedJoinComboFixture($database);
+
+        $any = [Permission::create(Role::any()), Permission::read(Role::any())];
+        $database->updateCollection($selfCol, $any, false);
+        $database->updateCollection($cCol, $any, false);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $selfCol, $cCol, $any): void {
+            $visible = $database->find($mCol, [
+                Query::join($selfCol, '$id', 'mainId', '=', 'mid'),
+                Query::join($cCol, 'mid.$id', 'selfId', '=', 'c'),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($visible));
+            $visibleEncoded = \json_encode(\array_map(static function (Document $document): array {
+                /** @var array<string, mixed> $copy */
+                $copy = $document->getArrayCopy();
+
+                return $copy;
+            }, $visible));
+            $this->assertNotFalse($visibleEncoded);
+            $this->assertSame(true, \str_contains($visibleEncoded, 'c-combo-secret'));
+
+            $database->updateCollection($cCol, $any, true);
+
+            $hidden = $database->find($mCol, [
+                Query::join($selfCol, '$id', 'mainId', '=', 'mid'),
+                Query::join($cCol, 'mid.$id', 'selfId', '=', 'c'),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($hidden));
+            $this->assertComboSecretsHidden($hidden);
+            foreach ($hidden as $document) {
+                $this->assertNotSame('c-combo-secret', $document->getId());
+                $this->assertNotSame('c-combo-secret', $document->getAttribute('secret'));
+                $this->assertNotSame('c-combo-secret', $document->getAttribute('selfId'));
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboCountMatchesFindWhenFilteringJoinAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol, $secCol] = $this->seedJoinComboFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol, $secCol): void {
+            $visible = [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::equal('sec.score', [313]),
+            ];
+            $found = $database->find($mCol, $visible);
+            $this->assertSame(\count($found), $database->count($mCol, $visible));
+            $this->assertGreaterThan(0, \count($found));
+            $this->assertComboSecretsHidden($found);
+            $this->assertContains(313, $this->comboNumericScores($found));
+
+            $hiddenScore = [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::equal('sec.score', [777]),
+            ];
+            $hiddenScoreFound = $database->find($mCol, $hiddenScore);
+            $this->assertSame(0, \count($hiddenScoreFound));
+            $this->assertSame(0, $database->count($mCol, $hiddenScore));
+            $this->assertComboSecretsHidden($hiddenScoreFound);
+
+            $hiddenSecret = [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::join($secCol, '$id', 'mainId', '=', 'sec'),
+                Query::equal('sec.secret', ['combo-secret-alpha']),
+            ];
+            $hiddenSecretFound = $database->find($mCol, $hiddenSecret);
+            $this->assertSame(0, \count($hiddenSecretFound));
+            $this->assertSame(0, $database->count($mCol, $hiddenSecret));
+            $this->assertComboSecretsHidden($hiddenSecretFound);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinComboDottedAttributeNameDoesNotSplitAsAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $pubCol] = $this->seedJoinComboFixture($database);
+        $database->createAttribute($mCol, Attribute::integer(key: 'rev.score'));
+        $database->getAuthorization()->skip(function () use ($database, $mCol): void {
+            $database->deleteDocument($mCol, 'm1');
+            $database->deleteDocument($mCol, 'm2');
+            $database->createDocument($mCol, new Document([
+                '$id' => 'm1',
+                'name' => 'Main',
+                'rev.score' => 21,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($mCol, new Document([
+                '$id' => 'm2',
+                'name' => 'Unmatched',
+                'rev.score' => 22,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        });
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $pubCol): void {
+            $selected = $database->find($mCol, [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::select(['name', 'rev.score']),
+                Query::orderDesc('rev.score'),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($selected));
+            $this->assertComboSecretsHidden($selected);
+
+            $dotted = [];
+            foreach ($selected as $document) {
+                $value = $document->getAttribute('rev.score') ?? $document->getAttribute('revscore');
+                if (\is_numeric($value)) {
+                    $dotted[] = (int) $value;
+                }
+            }
+            $this->assertContains(21, $dotted);
+            $this->assertContains(22, $dotted);
+            $this->assertSame(false, \in_array(313, $dotted, true));
+            $this->assertSame(false, \in_array(777, $dotted, true));
+
+            $filtered = $database->find($mCol, [
+                Query::leftJoin($pubCol, '$id', 'mainId', '=', 'pub'),
+                Query::equal('rev.score', [21]),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($filtered));
+            $this->assertComboSecretsHidden($filtered);
+            foreach ($filtered as $document) {
+                $value = $document->getAttribute('rev.score') ?? $document->getAttribute('revscore');
+                $this->assertTrue(\is_numeric($value));
+                $this->assertSame(21, (int) $value);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinComboCollections());
+    }
+
+    public function testJoinHardcoreNestedJsonAndJoinAliasSameQuery(): void
+    {
+        $database = static::getDatabase();
+        if (
+            ! $database->getAdapter()->supports(Capability::Joins)
+            || ! $database->getAdapter()->supports(Capability::Objects)
+        ) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $database->createAttribute($mCol, Attribute::object(key: 'profile'));
+        if ($database->getAdapter()->supports(Capability::ObjectIndexes)) {
+            $database->createIndex($mCol, Index::key(key: 'idx_jh_profile_email', attributes: ['profile.user.email']));
+        }
+
+        $database->getAuthorization()->skip(function () use ($database, $mCol): void {
+            $main = $database->getDocument($mCol, 'hm1');
+            $main->setAttribute('profile', [
+                'user' => [
+                    'email' => 'alice@hard.example',
+                ],
+            ]);
+            $database->updateDocument($mCol, 'hm1', $main);
+
+            $second = $database->getDocument($mCol, 'hm2');
+            $second->setAttribute('profile', [
+                'user' => [
+                    'email' => 'bob@hard.example',
+                ],
+            ]);
+            $database->updateDocument($mCol, 'hm2', $second);
+        });
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::select(['name', 'profile', 'meta.score']),
+                Query::equal('profile.user.email', ['alice@hard.example']),
+                Query::equal('meta.score', [10]),
+                Query::orderDesc('meta.score'),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+            $this->assertSame('hm1', $results[0]->getId());
+            $this->assertSame('Main', $results[0]->getAttribute('name'));
+
+            $profile = $results[0]->getAttribute('profile');
+            $this->assertTrue(\is_array($profile));
+            $user = $profile['user'] ?? null;
+            $this->assertTrue(\is_array($user));
+            $this->assertSame('alice@hard.example', $user['email'] ?? null);
+
+            $score = $results[0]->getAttribute('meta.score') ?? $results[0]->getAttribute('score');
+            $this->assertTrue(\is_numeric($score));
+            $this->assertSame(10, (int) $score);
+            $this->assertSame(false, \in_array(8686, $this->comboNumericScores($results), true));
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreSameTableTwoAliasesIndependentPredicates(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $peerCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $peerCol): void {
+            $results = $database->find($mCol, [
+                Query::join($peerCol, '$id', 'mainId', '=', 'alpha'),
+                Query::join($peerCol, 'peerKey', '$id', '=', 'beta'),
+                Query::equal('alpha.label', ['alpha-one']),
+                Query::equal('beta.label', ['beta-key']),
+                Query::select(['name', 'alpha.$id', 'beta.$id', 'alpha.label', 'beta.label', 'alpha.score']),
+                Query::orderDesc('alpha.score'),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+            $this->assertSame('hm1', $results[0]->getId());
+            $this->assertSame('Main', $results[0]->getAttribute('name'));
+            $this->assertSame('peer-a', $results[0]->getAttribute('alpha.$id'));
+            $this->assertSame('peer-b', $results[0]->getAttribute('beta.$id'));
+            $this->assertSame('alpha-one', $results[0]->getAttribute('alpha.label'));
+            $this->assertSame('beta-key', $results[0]->getAttribute('beta.label'));
+            $this->assertNotSame('peer-a', $results[0]->getId());
+            $this->assertNotSame('peer-b', $results[0]->getId());
+            $this->assertNotSame('peer-hidden', $results[0]->getId());
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreSelfJoinOnIdDoesNotSmashIdentity(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol): void {
+            $results = $database->find($mCol, [
+                Query::join($mCol, '$id', '$id', '=', 'twin'),
+                Query::select(['name', 'rank', 'twin.$id', 'twin.name', 'twin.$permissions']),
+                Query::orderAsc('rank'),
+            ]);
+
+            $this->assertSame(3, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $names = [
+                'hm1' => 'Main',
+                'hm2' => 'Second',
+                'hm3' => 'Third',
+            ];
+            $ids = [];
+            foreach ($results as $document) {
+                $id = $document->getId();
+                $ids[] = $id;
+                $this->assertArrayHasKey($id, $names);
+                $this->assertSame($names[$id], $document->getAttribute('name'));
+                $this->assertSame($id, $document->getAttribute('twin.$id'));
+                $this->assertSame($names[$id], $document->getAttribute('twin.name'));
+            }
+            \sort($ids);
+            $this->assertSame(['hm1', 'hm2', 'hm3'], $ids);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreLeftInnerRightMixedDocSec(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol, , , $bCol, $cCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol, $bCol, $cCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::join($bCol, '$id', 'mainId', '=', 'mid'),
+                Query::rightJoin($cCol, '$id', 'mainId', '=', 'tail'),
+                Query::select(['name', 'meta.score', 'mid.label', 'tail.secret', 'tail.score']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+            $this->assertContains('hm1', $ids);
+            if (! $database->getSharedTables()) {
+                $this->assertContains('', $ids);
+            }
+            $this->assertSame(false, \in_array('hm2', $ids, true));
+            $this->assertSame(false, \in_array('hm3', $ids, true));
+            $this->assertSame(false, \in_array('hc-hidden', $ids, true));
+            $this->assertSame(false, \in_array('hc-right', $ids, true));
+
+            $labels = [];
+            foreach ($results as $document) {
+                $label = $document->getAttribute('mid.label') ?? $document->getAttribute('label');
+                if (\is_string($label) && $label !== '') {
+                    $labels[] = $label;
+                }
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('tail.secret'));
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('secret'));
+            }
+            $this->assertContains('b-public', $labels);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreChainAOnBOffCOnHidesC(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [, , , $aCol, $bCol, $cCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $aCol, $bCol, $cCol): void {
+            $results = $database->find($aCol, [
+                Query::distinct(),
+                Query::join($bCol, '$id', 'aId', '=', 'b'),
+                Query::join($cCol, 'b.$id', 'bId', '=', 'c'),
+                Query::select(['$id', 'name', 'b.label', 'c.secret', 'c.score']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $labels = [];
+            foreach ($results as $document) {
+                $this->assertSame('ha1', $document->getId());
+                $label = $document->getAttribute('b.label') ?? $document->getAttribute('label');
+                if (\is_string($label) && $label !== '') {
+                    $labels[] = $label;
+                }
+                $this->assertNotSame('hc-hidden', $document->getId());
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('c.secret'));
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('secret'));
+                $score = $document->getAttribute('c.score') ?? $document->getAttribute('score');
+                if (\is_numeric($score)) {
+                    $this->assertNotSame(8686, (int) $score);
+                }
+            }
+            $this->assertContains('b-public', $labels);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreFullOuterJoinSideCursorPageWalk(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $ordered = [
+                Query::fullOuterJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::orderAsc('meta.score'),
+            ];
+
+            $full = $database->find($mCol, $ordered);
+            $this->assertGreaterThanOrEqual(2, \count($full));
+            $this->assertComboSecretsHidden($full);
+
+            $fullScores = $this->comboNumericScores($full);
+            $this->assertContains(10, $fullScores);
+            $this->assertContains(15, $fullScores);
+            $this->assertContains(20, $fullScores);
+            $this->assertContains(42, $fullScores);
+            $this->assertContains(313, $fullScores);
+            $this->assertSame(false, \in_array(8686, $fullScores, true));
+            $this->assertSame($fullScores, $this->sortedAsc($fullScores));
+
+            $cursor = null;
+            foreach ($full as $document) {
+                $score = $this->comboJoinScore($document);
+                if ($document->getId() !== '' && $score !== null) {
+                    $cursor = $document;
+                    break;
+                }
+            }
+            $this->assertNotNull($cursor);
+            $this->assertNotSame('', $cursor->getId());
+            $cursorScore = $this->comboJoinScore($cursor);
+            $this->assertNotNull($cursorScore);
+
+            $after = $database->find($mCol, [
+                ...$ordered,
+                Query::cursorAfter($cursor),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($after));
+            $this->assertComboSecretsHidden($after);
+            $afterScore = $this->comboJoinScore($after[0]);
+            $this->assertNotNull($afterScore);
+
+            $cursorIndex = \array_search($cursorScore, $fullScores, true);
+            $this->assertNotSame(false, $cursorIndex);
+            $nextIndex = (int) $cursorIndex + 1;
+            $this->assertArrayHasKey($nextIndex, $fullScores);
+            $this->assertSame($fullScores[$nextIndex], $afterScore);
+
+            $beforeCursor = null;
+            for ($index = \count($full) - 1; $index >= 0; $index--) {
+                $score = $this->comboJoinScore($full[$index]);
+                if ($full[$index]->getId() !== '' && $score !== null) {
+                    $beforeCursor = $full[$index];
+                    break;
+                }
+            }
+            $this->assertNotNull($beforeCursor);
+            $this->assertNotSame('', $beforeCursor->getId());
+            $beforeCursorScore = $this->comboJoinScore($beforeCursor);
+            $this->assertNotNull($beforeCursorScore);
+
+            $before = $database->find($mCol, [
+                ...$ordered,
+                Query::cursorBefore($beforeCursor),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($before));
+            $this->assertComboSecretsHidden($before);
+            $beforeScore = $this->comboJoinScore($before[0]);
+            $this->assertNotNull($beforeScore);
+
+            $beforeIndex = \array_search($beforeCursorScore, $fullScores, true);
+            $this->assertNotSame(false, $beforeIndex);
+            $previousIndex = (int) $beforeIndex - 1;
+            $this->assertArrayHasKey($previousIndex, $fullScores);
+            $this->assertSame($fullScores[$previousIndex], $beforeScore);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreAndOrMixMainAndJoinFilters(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $mixed = $database->find($mCol, [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::and([
+                    Query::equal('name', ['Main']),
+                    Query::or([
+                        Query::equal('meta.score', [10]),
+                        Query::equal('rank', [2]),
+                    ]),
+                ]),
+                Query::select(['name', 'meta.score']),
+            ]);
+
+            $this->assertSame(1, \count($mixed));
+            $this->assertComboSecretsHidden($mixed);
+            $this->assertSame('hm1', $mixed[0]->getId());
+            $score = $mixed[0]->getAttribute('meta.score') ?? $mixed[0]->getAttribute('score');
+            $this->assertTrue(\is_numeric($score));
+            $this->assertSame(10, (int) $score);
+
+            $hiddenOnly = $database->find($mCol, [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::and([
+                    Query::equal('name', ['Main']),
+                    Query::or([
+                        Query::equal('meta.score', [8686]),
+                        Query::equal('meta.secret', ['combo-hard-alpha']),
+                    ]),
+                ]),
+            ]);
+            $this->assertSame(0, \count($hiddenOnly));
+            $this->assertComboSecretsHidden($hiddenOnly);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreMixedMainJoinOrderCursor(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $ordered = [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::orderAsc('rank'),
+                Query::orderDesc('meta.score'),
+            ];
+
+            $full = $database->find($mCol, $ordered);
+            $this->assertSame(4, \count($full));
+            $this->assertComboSecretsHidden($full);
+            $this->assertSame([313, 15, 10, 20], $this->comboNumericScores($full));
+
+            $first = $database->find($mCol, [
+                ...$ordered,
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($first));
+            $this->assertComboSecretsHidden($first);
+            $this->assertSame('hm1', $first[0]->getId());
+            $this->assertSame(313, $this->comboNumericScores($first)[0]);
+
+            $next = $database->find($mCol, [
+                ...$ordered,
+                Query::cursorAfter($first[0]),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($next));
+            $this->assertComboSecretsHidden($next);
+            $this->assertSame($full[1]->getId(), $next[0]->getId());
+            $this->assertSame(15, $this->comboNumericScores($next)[0]);
+
+            $before = $database->find($mCol, [
+                ...$ordered,
+                Query::cursorBefore($next[0]),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($before));
+            $this->assertComboSecretsHidden($before);
+            $this->assertSame($first[0]->getId(), $before[0]->getId());
+            $this->assertSame(313, $this->comboNumericScores($before)[0]);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreJoinSideOperatorsAndInternalAttrs(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::containsString('meta.body', ['hard-needle']),
+                Query::between('meta.score', 1, 50),
+                Query::startsWith('meta.label', 'visible'),
+                Query::equal('meta.$id', ['hm-meta-10']),
+                Query::greaterThan('meta.$createdAt', '2000-01-01 00:00:00.000'),
+                Query::select(['name', 'meta.$id', 'meta.score', 'meta.label', 'meta.body']),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+            $this->assertSame('hm1', $results[0]->getId());
+            $this->assertSame('hm-meta-10', $results[0]->getAttribute('meta.$id'));
+            $score = $results[0]->getAttribute('meta.score') ?? $results[0]->getAttribute('score');
+            $this->assertTrue(\is_numeric($score));
+            $this->assertSame(10, (int) $score);
+
+            if (
+                $database->getAdapter()->supports(Capability::Fulltext)
+                && $this->joinHardcoreHasFulltextIndex($database, $metaCol)
+            ) {
+                $searched = $database->find($mCol, [
+                    Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                    Query::search('meta.body', 'needle'),
+                ]);
+                $this->assertGreaterThanOrEqual(1, \count($searched));
+                $this->assertComboSecretsHidden($searched);
+                $this->assertSame('hm1', $searched[0]->getId());
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreRightUnmatchedMainIdentityAndSelectSubset(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $results = $database->find($mCol, [
+                Query::rightJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(2, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $unmatched = null;
+            $ids = [];
+            foreach ($results as $document) {
+                $ids[] = $document->getId();
+                $this->assertNotSame('hm-meta-orphan', $document->getId());
+                $this->assertNotSame('hm-meta-secret', $document->getId());
+                $this->assertNotSame('hm-meta-10', $document->getId());
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('meta.secret'));
+                $this->assertNotSame('combo-hard-alpha', $document->getAttribute('secret'));
+                if ($document->getId() === '') {
+                    $unmatched = $document;
+                }
+            }
+
+            $this->assertNotNull($unmatched);
+            $this->assertSame('', $unmatched->getId());
+            $this->assertTrue($unmatched->getAttribute('name') === null || $unmatched->getAttribute('name') === '');
+            $orphanScore = $unmatched->getAttribute('meta.score') ?? $unmatched->getAttribute('score');
+            $this->assertTrue(\is_numeric($orphanScore));
+            $this->assertSame(42, (int) $orphanScore);
+            $this->assertSame(false, \in_array('hm-meta-orphan', $ids, true));
+            $this->assertContains('hm1', $ids);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreCoerceSecret8686AbsentWhenUnauthorized(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $results = $database->find($mCol, [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::equal('meta.score', ['8686']),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ]);
+
+            $this->assertSame(0, \count($results));
+            $this->assertComboSecretsHidden($results);
+
+            $encoded = \json_encode(\array_map(static function (Document $document): array {
+                /** @var array<string, mixed> $copy */
+                $copy = $document->getArrayCopy();
+
+                return $copy;
+            }, $results));
+            $this->assertNotFalse($encoded);
+            $this->assertSame(false, $this->comboEncodedJsonContainsScalar($encoded, 8686));
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreSharedTablesSecret5151NotTenant(): void
+    {
+        $database = static::getDatabase();
+        if (
+            ! $database->getAdapter()->supports(Capability::Joins)
+            || ! $database->getAdapter()->supports(Capability::Schemas)
+        ) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $sharedTables = $database->getSharedTables();
+        $namespace = $database->getNamespace();
+        $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
+
+        $sharedTablesDb = 'sharedTablesJh_'.static::getTestToken();
+        $mCol = 'jh_m';
+        $metaCol = 'jh_meta';
+
+        try {
+            if ($database->exists($sharedTablesDb)) {
+                $database->setDatabase($sharedTablesDb)->delete();
+            }
+
+            $database
+                ->setDatabase($sharedTablesDb)
+                ->setNamespace('')
+                ->setSharedTables(true)
+                ->setTenant(null)
+                ->create();
+
+            $any = [Permission::create(Role::any()), Permission::read(Role::any())];
+            $database->createCollection(new Collection(id: $mCol, permissions: $any, documentSecurity: false));
+            $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+            $database->createCollection(new Collection(id: $metaCol, permissions: $any));
+            $database->createAttribute($metaCol, Attribute::string(key: 'mainId', required: true));
+            $database->createAttribute($metaCol, Attribute::integer(key: 'score', required: true));
+            $database->createAttribute($metaCol, Attribute::string(key: 'secret', size: 100));
+
+            $database->setTenant(5151);
+            $database->createDocument($mCol, new Document([
+                '$id' => 'hm1',
+                'name' => 'Main',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($metaCol, new Document([
+                '$id' => 'hm-meta-10',
+                'mainId' => 'hm1',
+                'score' => 10,
+                'secret' => 'visible',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($metaCol, new Document([
+                '$id' => 'hm-meta-secret',
+                'mainId' => 'hm1',
+                'score' => 5151,
+                'secret' => 'combo-hard-alpha',
+                '$permissions' => [
+                    Permission::read(Role::user('combo-hard-hidden')),
+                ],
+            ]));
+
+            $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+                $results = $database->find($mCol, [
+                    Query::leftJoin($metaCol, '$id', 'mainId', '=', 'sec'),
+                    Query::select(['name', 'sec.score', 'sec.secret', 'sec.$tenant']),
+                ]);
+
+                $this->assertGreaterThanOrEqual(1, \count($results));
+                $this->assertComboSecretsHidden($results);
+
+                $payloads = [];
+                foreach ($results as $document) {
+                    $this->assertSame('hm1', $document->getId());
+                    $this->assertNotSame('hm-meta-secret', $document->getId());
+                    $score = $document->getAttribute('sec.score') ?? $document->getAttribute('score');
+                    if (\is_numeric($score)) {
+                        $payloads[] = (int) $score;
+                    }
+                    $this->assertNotSame('combo-hard-alpha', $document->getAttribute('sec.secret'));
+                    $this->assertNotSame('combo-hard-alpha', $document->getAttribute('secret'));
+                }
+                $this->assertContains(10, $payloads);
+                $this->assertSame(false, \in_array(5151, $payloads, true));
+
+                $encoded = \json_encode(\array_map(static function (Document $document): array {
+                    /** @var array<string, mixed> $copy */
+                    $copy = $document->getArrayCopy();
+
+                    return $copy;
+                }, $results));
+                $this->assertNotFalse($encoded);
+                $this->assertSame(false, $this->comboEncodedJsonContainsScalar($encoded, 5151));
+                $this->assertSame(false, \str_contains($encoded, 'combo-hard-alpha'));
+            });
+        } finally {
+            $database->setTenant(null)->setSharedTables(false);
+            if ($database->exists($sharedTablesDb)) {
+                $database->delete($sharedTablesDb);
+            }
+            $database
+                ->setSharedTables($sharedTables)
+                ->setTenant($tenant)
+                ->setNamespace($namespace)
+                ->setDatabase($schema);
+        }
+    }
+
+    public function testJoinHardcoreSkipAuthMixedDocSecStillHidesSecrets(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $withoutJoins = $database->find($mCol);
+            $this->assertSame(3, \count($withoutJoins));
+            $this->assertComboSecretsHidden($withoutJoins);
+            $withoutIds = \array_map(static fn (Document $document): string => $document->getId(), $withoutJoins);
+            \sort($withoutIds);
+            $this->assertSame(['hm1', 'hm2', 'hm3'], $withoutIds);
+
+            $joinedQueries = [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ];
+            $joined = $database->find($mCol, $joinedQueries);
+            $this->assertSame(4, \count($joined));
+            $this->assertComboSecretsHidden($joined);
+
+            $scores = $this->comboNumericScores($joined);
+            $this->assertContains(10, $scores);
+            $this->assertContains(313, $scores);
+            $this->assertContains(20, $scores);
+            $this->assertContains(15, $scores);
+            $this->assertSame(false, \in_array(8686, $scores, true));
+            $this->assertSame(false, \in_array(42, $scores, true));
+
+            $this->assertSame(\count($joined), $database->count($mCol, $joinedQueries));
+
+            $sum = $database->sum($mCol, 'meta.score', [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+            ]);
+            $this->assertSame(358, (int) $sum);
+
+            $document = $database->getDocument($mCol, 'hm1', $joinedQueries);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertSame('hm1', $document->getId());
+            $this->assertComboSecretsHidden([$document]);
+            $documentScore = $document->getAttribute('meta.score') ?? $document->getAttribute('score');
+            if (\is_numeric($documentScore)) {
+                $this->assertContains((int) $documentScore, [10, 313]);
+                $this->assertNotSame(8686, (int) $documentScore);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreNestedAndOrTwoAliasesIndependent(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, , $peerCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $peerCol): void {
+            $results = $database->find($mCol, [
+                Query::join($peerCol, '$id', 'mainId', '=', 'alpha'),
+                Query::join($peerCol, 'peerKey', '$id', '=', 'beta'),
+                Query::and([
+                    Query::equal('alpha.label', ['alpha-one']),
+                    Query::or([
+                        Query::equal('beta.label', ['beta-key']),
+                        Query::equal('alpha.score', [8686]),
+                    ]),
+                ]),
+                Query::select(['name', 'alpha.$id', 'beta.$id', 'alpha.label', 'beta.label']),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertComboSecretsHidden($results);
+            $this->assertSame('hm1', $results[0]->getId());
+            $this->assertSame('peer-a', $results[0]->getAttribute('alpha.$id'));
+            $this->assertSame('peer-b', $results[0]->getAttribute('beta.$id'));
+            $this->assertSame('alpha-one', $results[0]->getAttribute('alpha.label'));
+            $this->assertSame('beta-key', $results[0]->getAttribute('beta.label'));
+            $this->assertNotSame('peer-a', $results[0]->getId());
+            $this->assertNotSame('peer-b', $results[0]->getId());
+            $this->assertNotSame('peer-hidden', $results[0]->getId());
+
+            $hiddenOnly = $database->find($mCol, [
+                Query::join($peerCol, '$id', 'mainId', '=', 'alpha'),
+                Query::join($peerCol, 'peerKey', '$id', '=', 'beta'),
+                Query::or([
+                    Query::equal('alpha.score', [8686]),
+                    Query::equal('beta.secret', ['combo-hard-alpha']),
+                ]),
+            ]);
+            $this->assertSame(0, \count($hiddenOnly));
+            $this->assertComboSecretsHidden($hiddenOnly);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreLeftOnVsInnerWhereVsFojNull(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $left = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+            ]);
+            $this->assertGreaterThanOrEqual(3, \count($left));
+            $this->assertComboSecretsHidden($left);
+            $leftIds = \array_map(static fn (Document $document): string => $document->getId(), $left);
+            $this->assertContains('hm1', $leftIds);
+            $this->assertContains('hm2', $leftIds);
+            $this->assertContains('hm3', $leftIds);
+            $leftScores = $this->comboNumericScores($left);
+            $this->assertContains(10, $leftScores);
+            $this->assertContains(313, $leftScores);
+            $this->assertSame(false, \in_array(8686, $leftScores, true));
+            $this->assertSame(false, \in_array(42, $leftScores, true));
+
+            $innerHidden = $database->find($mCol, [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::equal('meta.score', [8686]),
+            ]);
+            $this->assertSame(0, \count($innerHidden));
+            $this->assertComboSecretsHidden($innerHidden);
+
+            $foj = $database->find($mCol, [
+                Query::fullOuterJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+            ]);
+            $this->assertGreaterThanOrEqual(2, \count($foj));
+            $this->assertComboSecretsHidden($foj);
+            $fojScores = $this->comboNumericScores($foj);
+            $this->assertContains(42, $fojScores);
+            $this->assertSame(false, \in_array(8686, $fojScores, true));
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreFojPlusSecondAliasCursorRemap(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol, $peerCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol, $peerCol): void {
+            $ordered = [
+                Query::fullOuterJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::join($peerCol, '$id', 'mainId', '=', 'peer'),
+                Query::orderAsc('meta.score'),
+                Query::select(['name', 'meta.$id', 'meta.score', 'peer.$id', 'peer.label']),
+            ];
+
+            $full = $database->find($mCol, $ordered);
+            $this->assertGreaterThanOrEqual(2, \count($full));
+            $this->assertComboSecretsHidden($full);
+
+            $fullScores = $this->comboNumericScores($full);
+            $this->assertSame(false, \in_array(8686, $fullScores, true));
+            $this->assertSame($fullScores, $this->sortedAsc($fullScores));
+
+            foreach ($full as $document) {
+                $id = $document->getId();
+                $this->assertTrue($id === '' || \in_array($id, ['hm1', 'hm2', 'hm3'], true));
+            }
+
+            $cursor = null;
+            $cursorIndex = null;
+            foreach ($full as $index => $document) {
+                $score = $this->comboJoinScore($document);
+                if ($document->getId() !== '' && $score !== null) {
+                    $cursor = $document;
+                    $cursorIndex = $index;
+                    break;
+                }
+            }
+            $this->assertNotNull($cursor);
+            $this->assertNotSame('', $cursor->getId());
+            $this->assertNotNull($cursorIndex);
+            $cursorScore = $this->comboJoinScore($cursor);
+            $this->assertNotNull($cursorScore);
+
+            $after = $database->find($mCol, [
+                ...$ordered,
+                Query::cursorAfter($cursor),
+                Query::limit(1),
+            ]);
+            $this->assertSame(1, \count($after));
+            $this->assertComboSecretsHidden($after);
+            $afterScore = $this->comboJoinScore($after[0]);
+            $this->assertNotNull($afterScore);
+            $this->assertTrue($after[0]->getId() === '' || \in_array($after[0]->getId(), ['hm1', 'hm2', 'hm3'], true));
+
+            $expectedScore = null;
+            for ($index = (int) $cursorIndex + 1, $total = \count($full); $index < $total; $index++) {
+                $score = $this->comboJoinScore($full[$index]);
+                if ($score === null) {
+                    continue;
+                }
+                if ($score === $cursorScore && $full[$index]->getId() === $cursor->getId()) {
+                    continue;
+                }
+                $expectedScore = $score;
+                break;
+            }
+            $this->assertNotNull($expectedScore);
+            $this->assertSame($expectedScore, $afterScore);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreGetDocumentSelectDottedJoinInternals(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $queries = [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::select(['name', 'meta.score', 'meta.$id', 'meta.$permissions']),
+            ];
+
+            $hm1 = $database->getDocument($mCol, 'hm1', $queries);
+            $this->assertSame(false, $hm1->isEmpty());
+            $this->assertSame('hm1', $hm1->getId());
+            $this->assertContains($hm1->getAttribute('meta.$id'), ['hm-meta-10', 'hm-meta-313']);
+            $this->assertNotSame($hm1->getId(), $hm1->getAttribute('meta.$id'));
+
+            $hm2 = $database->getDocument($mCol, 'hm2', $queries);
+            $this->assertSame(false, $hm2->isEmpty());
+            $this->assertSame('hm2', $hm2->getId());
+            $this->assertSame('hm-meta-20', $hm2->getAttribute('meta.$id'));
+            $this->assertNotSame($hm2->getId(), $hm2->getAttribute('meta.$id'));
+
+            foreach ([$hm1, $hm2] as $document) {
+                $score = $document->getAttribute('meta.score') ?? $document->getAttribute('score');
+                if (\is_numeric($score)) {
+                    $this->assertNotSame(8686, (int) $score);
+                }
+                $permissions = $document->getAttribute('meta.$permissions');
+                if (\is_string($permissions)) {
+                    $permissions = \json_decode($permissions, true);
+                }
+                if (\is_array($permissions)) {
+                    foreach ($permissions as $permission) {
+                        if (\is_string($permission)) {
+                            $this->assertSame(false, \str_contains($permission, 'user:combo-hard-hidden'));
+                        }
+                    }
+                }
+            }
+
+            $this->assertComboSecretsHidden([$hm1, $hm2]);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreCountSumFojExcludesSecret(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $foj = [
+                Query::fullOuterJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+            ];
+            $found = $database->find($mCol, $foj);
+            $this->assertGreaterThanOrEqual(2, \count($found));
+            $this->assertComboSecretsHidden($found);
+            $this->assertSame(\count($found), $database->count($mCol, $foj));
+            $this->assertSame(false, \in_array(8686, $this->comboNumericScores($found), true));
+            $this->assertContains(42, $this->comboNumericScores($found));
+
+            $this->assertSame(0, $database->count($mCol, [
+                Query::fullOuterJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::equal('meta.score', [8686]),
+            ]));
+
+            $sum = $database->sum($mCol, 'meta.score', $foj);
+            $this->assertSame(400, (int) $sum);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreIsNotNullNotEqualSecretDoesNotLeak(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol): void {
+            $notNull = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::isNotNull('meta.secret'),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($notNull));
+            $this->assertComboSecretsHidden($notNull);
+
+            $secrets = [];
+            foreach ($notNull as $document) {
+                $secret = $document->getAttribute('meta.secret') ?? $document->getAttribute('secret');
+                if (\is_string($secret) && $secret !== '') {
+                    $secrets[] = $secret;
+                }
+                $score = $document->getAttribute('meta.score') ?? $document->getAttribute('score');
+                if (\is_numeric($score)) {
+                    $this->assertNotSame(8686, (int) $score);
+                }
+            }
+            $this->assertContains('visible', $secrets);
+            $this->assertContains('visible-313', $secrets);
+            $this->assertContains('visible-20', $secrets);
+            $this->assertContains('visible-15', $secrets);
+            $this->assertSame(false, \in_array('combo-hard-alpha', $secrets, true));
+
+            $notEqual = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::notEqual('meta.score', 8686),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($notEqual));
+            $this->assertComboSecretsHidden($notEqual);
+            $this->assertSame(false, \in_array(8686, $this->comboNumericScores($notEqual), true));
+
+            $notContains = $database->find($mCol, [
+                Query::leftJoin($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::notContains('meta.secret', ['combo-hard-alpha']),
+                Query::select(['name', 'meta.score', 'meta.secret']),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($notContains));
+            $this->assertComboSecretsHidden($notContains);
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    public function testJoinHardcoreStaleJoinAliasRejectedOnSecondFind(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        [$mCol, $metaCol, $peerCol] = $this->seedJoinHardcoreFixture($database);
+
+        $this->withComboRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $metaCol, $peerCol): void {
+            $first = $database->find($mCol, [
+                Query::join($metaCol, '$id', 'mainId', '=', 'meta'),
+                Query::equal('meta.score', [10]),
+            ]);
+            $this->assertSame(1, \count($first));
+            $this->assertComboSecretsHidden($first);
+            $this->assertSame('hm1', $first[0]->getId());
+            $this->assertSame(false, \in_array(8686, $this->comboNumericScores($first), true));
+
+            try {
+                $database->find($mCol, [
+                    Query::join($peerCol, '$id', 'mainId', '=', 'peer'),
+                    Query::equal('meta.score', [8686]),
+                ]);
+                $this->fail('Expected QueryException for stale join alias');
+            } catch (QueryException $exception) {
+                $this->assertStringContainsString('Attribute not found', $exception->getMessage());
+            }
+        });
+
+        $this->cleanupAggCollections($database, $this->joinHardcoreCollections());
+    }
+
+    /**
+     * @return list<string>
+     */
+    private function joinComboCollections(): array
+    {
+        return ['jc_m', 'jc_pub', 'jc_sec', 'jc_self', 'jc_c'];
+    }
+
+    /**
+     * @return array{0: string, 1: string, 2: string, 3: string, 4: string}
+     */
+    private function seedJoinComboFixture(Database $database): array
+    {
+        $mCol = 'jc_m';
+        $pubCol = 'jc_pub';
+        $secCol = 'jc_sec';
+        $selfCol = 'jc_self';
+        $cCol = 'jc_c';
+        $this->cleanupAggCollections($database, [$mCol, $pubCol, $secCol, $selfCol, $cCol]);
+
+        $any = [Permission::create(Role::any()), Permission::read(Role::any())];
+
+        $database->createCollection(new Collection(id: $mCol, permissions: $any, documentSecurity: false));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $pubCol, permissions: $any));
+        $database->createAttribute($pubCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($pubCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createCollection(new Collection(id: $secCol, permissions: $any));
+        $database->createAttribute($secCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($secCol, Attribute::integer(key: 'score', required: true));
+        $database->createAttribute($secCol, Attribute::string(key: 'secret', size: 100));
+
+        $database->createCollection(new Collection(id: $selfCol, permissions: $any));
+        $database->createAttribute($selfCol, Attribute::string(key: 'payload', size: 100, required: true));
+        $database->createAttribute($selfCol, Attribute::string(key: 'tag', size: 50, required: true));
+        $database->createAttribute($selfCol, Attribute::string(key: 'mainId'));
+
+        $database->createCollection(new Collection(id: $cCol, permissions: $any));
+        $database->createAttribute($cCol, Attribute::string(key: 'selfId', required: true));
+        $database->createAttribute($cCol, Attribute::string(key: 'secret', size: 100, required: true));
+
+        $readAny = [Permission::read(Role::any())];
+        $hidden = [
+            Permission::read(Role::user('combo-hidden')),
+            Permission::update(Role::user('combo-secret-perm')),
+        ];
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'Unmatched',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($pubCol, new Document([
+            '$id' => 'j-pub-auth',
+            'mainId' => 'm1',
+            'score' => 313,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($pubCol, new Document([
+            '$id' => 'j-pub-sib',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($pubCol, new Document([
+            '$id' => 'j-pub-orphan',
+            'mainId' => 'missing',
+            'score' => 4242,
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($secCol, new Document([
+            '$id' => 'j-combo-auth',
+            'mainId' => 'm1',
+            'score' => 313,
+            'secret' => 'visible',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($secCol, new Document([
+            '$id' => 'j-combo-ten',
+            'mainId' => 'm1',
+            'score' => 10,
+            'secret' => 'visible-ten',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($secCol, new Document([
+            '$id' => 'j-combo-secret',
+            'mainId' => 'm1',
+            'score' => 777,
+            'secret' => 'combo-secret-alpha',
+            '$permissions' => $hidden,
+        ]));
+        $database->createDocument($secCol, new Document([
+            '$id' => 'j-combo-m2',
+            'mainId' => 'm2',
+            'score' => 313,
+            'secret' => 'visible-m2',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($selfCol, new Document([
+            '$id' => 'open',
+            'payload' => 'open-payload',
+            'tag' => 'shared',
+            'mainId' => 'm1',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($selfCol, new Document([
+            '$id' => 'hidden-self',
+            'payload' => 'combo-secret-alpha',
+            'tag' => 'shared',
+            'mainId' => 'm1',
+            '$permissions' => $hidden,
+        ]));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c-open',
+            'selfId' => 'open',
+            'secret' => 'c-open-token',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c-combo-secret',
+            'selfId' => 'open',
+            'secret' => 'c-combo-secret',
+            '$permissions' => $hidden,
+        ]));
+
+        return [$mCol, $pubCol, $secCol, $selfCol, $cCol];
+    }
+
+    /**
+     * @param list<string> $roles
+     * @param callable(): void $callback
+     */
+    private function withComboRoles(Database $database, array $roles, callable $callback): void
+    {
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        foreach ($roles as $role) {
+            $authorization->addRole($role);
+        }
+
+        try {
+            $callback();
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+        }
+    }
+
+    /**
+     * @param array<Document> $documents
+     */
+    private function assertComboSecretsHidden(array $documents): void
+    {
+        $payload = [];
+        foreach ($documents as $document) {
+            $this->assertComboSecretHidden($document);
+            $payload[] = $document->getArrayCopy();
+        }
+
+        $this->assertEncodedComboSecretHidden(\json_encode($payload));
+    }
+
+    private function assertComboSecretHidden(Document $document): void
+    {
+        $this->assertNotSame('j-combo-secret', $document->getId());
+        $this->assertNotSame('c-combo-secret', $document->getId());
+        $this->assertNotSame('hm-meta-secret', $document->getId());
+        $this->assertNotSame('peer-hidden', $document->getId());
+        $this->assertNotSame('hc-hidden', $document->getId());
+
+        foreach (['score', 'meta.score', 'sec.score', 'pub.score', 'rev.score', 'c.score', 'tail.score', 'alpha.score', 'beta.score', 'peer.score'] as $scoreKey) {
+            $score = $document->getAttribute($scoreKey);
+            if (\is_numeric($score)) {
+                $this->assertNotSame(777, (int) $score);
+                $this->assertNotSame(8686, (int) $score);
+                $this->assertNotSame(5151, (int) $score);
+            }
+        }
+
+        foreach (['secret', 'payload', 'meta.secret', 'sec.secret', 'c.secret', 'tail.secret', 'alpha.secret', 'beta.secret', 'peer.secret'] as $secretKey) {
+            $this->assertNotSame('combo-secret-alpha', $document->getAttribute($secretKey));
+            $this->assertNotSame('combo-hard-alpha', $document->getAttribute($secretKey));
+        }
+
+        foreach ($document->getPermissions() as $permission) {
+            $this->assertSame(false, \str_contains($permission, 'j-combo-secret'));
+            $this->assertSame(false, \str_contains($permission, 'c-combo-secret'));
+            $this->assertSame(false, \str_contains($permission, 'user:combo-hidden'));
+            $this->assertSame(false, \str_contains($permission, 'combo-secret-perm'));
+            $this->assertSame(false, \str_contains($permission, 'user:combo-hard-hidden'));
+            $this->assertSame(false, \str_contains($permission, 'combo-hard-alpha'));
+        }
+
+        $this->assertEncodedComboSecretHidden(\json_encode($document));
+    }
+
+    private function assertEncodedComboSecretHidden(string|false $encoded): void
+    {
+        $this->assertNotFalse($encoded);
+        $this->assertSame(false, \str_contains($encoded, 'j-combo-secret'));
+        $this->assertSame(false, \str_contains($encoded, 'c-combo-secret'));
+        $this->assertSame(false, \str_contains($encoded, 'user:combo-hidden'));
+        $this->assertSame(false, \str_contains($encoded, 'combo-secret-perm'));
+        $this->assertSame(false, \str_contains($encoded, 'combo-secret-alpha'));
+        $this->assertSame(false, \str_contains($encoded, 'combo-hard-alpha'));
+        $this->assertSame(false, \str_contains($encoded, 'user:combo-hard-hidden'));
+        $this->assertSame(false, $this->comboEncodedJsonContainsScalar($encoded, 777));
+        $this->assertSame(false, $this->comboEncodedJsonContainsScalar($encoded, 8686));
+        $this->assertSame(false, $this->comboEncodedJsonContainsScalar($encoded, 5151));
+    }
+
+    private function comboEncodedJsonContainsScalar(string $encoded, int $needle): bool
+    {
+        $decoded = \json_decode($encoded, true);
+        if (! \is_array($decoded)) {
+            return false;
+        }
+
+        return $this->comboJsonContainsScalar($decoded, $needle);
+    }
+
+    private function comboJsonContainsScalar(mixed $value, int $needle, string|int|null $key = null): bool
+    {
+        if (\is_int($value) || \is_float($value) || (\is_string($value) && \is_numeric($value))) {
+            if ($this->isIgnoredJoinComboSecretKey($key)) {
+                return false;
+            }
+
+            return (int) $value === $needle;
+        }
+
+        if (! \is_array($value)) {
+            return false;
+        }
+
+        foreach ($value as $childKey => $child) {
+            if ($this->comboJsonContainsScalar($child, $needle, $childKey)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function isIgnoredJoinComboSecretKey(string|int|null $key): bool
+    {
+        $name = \is_string($key) && \str_contains($key, '.')
+            ? \substr($key, (int) \strrpos($key, '.') + 1)
+            : $key;
+
+        return \in_array($name, [
+            Document::SEQUENCE,
+            Document::CREATED_AT,
+            Document::UPDATED_AT,
+            Document::TENANT,
+            Document::VERSION,
+            Document::COLLECTION,
+            Document::DISTANCE,
+            Document::DELETED_AT,
+            Document::INTERNAL_ID,
+            Document::SKIP_PERMISSIONS_UPDATE,
+        ], true);
+    }
+
+    /**
+     * @param array<Document> $documents
+     * @return list<int>
+     */
+    private function comboNumericScores(array $documents): array
+    {
+        $scores = [];
+        foreach ($documents as $document) {
+            $score = $this->comboJoinScore($document);
+            if ($score !== null) {
+                $scores[] = $score;
+            }
+        }
+
+        return $scores;
+    }
+
+    /**
+     * @param list<int> $scores
+     * @return list<int>
+     */
+    private function sortedDesc(array $scores): array
+    {
+        $sorted = $scores;
+        \rsort($sorted, SORT_NUMERIC);
+
+        return $sorted;
+    }
+
+    /**
+     * @param list<int> $scores
+     * @return list<int>
+     */
+    private function sortedAsc(array $scores): array
+    {
+        $sorted = $scores;
+        \sort($sorted, SORT_NUMERIC);
+
+        return $sorted;
+    }
+
+    private function comboJoinScore(Document $document): ?int
+    {
+        $score = $document->getAttribute('pub.score')
+            ?? $document->getAttribute('sec.score')
+            ?? $document->getAttribute('rev.score')
+            ?? $document->getAttribute('meta.score')
+            ?? $document->getAttribute('peer.score')
+            ?? $document->getAttribute('tail.score')
+            ?? $document->getAttribute('alpha.score')
+            ?? $document->getAttribute('beta.score')
+            ?? $document->getAttribute('score');
+        if (! \is_numeric($score)) {
+            return null;
+        }
+
+        return (int) $score;
+    }
+
+    /**
+     * @return list<string>
+     */
+    private function joinHardcoreCollections(): array
+    {
+        return ['jh_m', 'jh_meta', 'jh_peer', 'jh_a', 'jh_b', 'jh_c'];
+    }
+
+    /**
+     * @return array{0: string, 1: string, 2: string, 3: string, 4: string, 5: string}
+     */
+    private function seedJoinHardcoreFixture(Database $database): array
+    {
+        $mCol = 'jh_m';
+        $metaCol = 'jh_meta';
+        $peerCol = 'jh_peer';
+        $aCol = 'jh_a';
+        $bCol = 'jh_b';
+        $cCol = 'jh_c';
+        $this->cleanupAggCollections($database, [$mCol, $metaCol, $peerCol, $aCol, $bCol, $cCol]);
+
+        $any = [Permission::create(Role::any()), Permission::read(Role::any())];
+        $readAny = [Permission::read(Role::any())];
+        $hidden = [Permission::read(Role::user('combo-hard-hidden'))];
+
+        $database->createCollection(new Collection(id: $mCol, permissions: $any, documentSecurity: false));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+        $database->createAttribute($mCol, Attribute::integer(key: 'rank', required: true));
+        $database->createAttribute($mCol, Attribute::string(key: 'peerKey'));
+
+        $database->createCollection(new Collection(id: $metaCol, permissions: $any));
+        $database->createAttribute($metaCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($metaCol, Attribute::integer(key: 'score', required: true));
+        $database->createAttribute($metaCol, Attribute::string(key: 'secret', size: 100));
+        $database->createAttribute($metaCol, Attribute::string(key: 'label', size: 100));
+        $database->createAttribute($metaCol, Attribute::string(key: 'body'));
+
+        $database->createCollection(new Collection(id: $peerCol, permissions: $any));
+        $database->createAttribute($peerCol, Attribute::string(key: 'mainId'));
+        $database->createAttribute($peerCol, Attribute::string(key: 'label', size: 100, required: true));
+        $database->createAttribute($peerCol, Attribute::integer(key: 'score', required: true));
+        $database->createAttribute($peerCol, Attribute::string(key: 'secret', size: 100));
+
+        $database->createCollection(new Collection(id: $aCol, permissions: $any));
+        $database->createAttribute($aCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $bCol, permissions: $any, documentSecurity: false));
+        $database->createAttribute($bCol, Attribute::string(key: 'aId', required: true));
+        $database->createAttribute($bCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($bCol, Attribute::string(key: 'label', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $cCol, permissions: $any));
+        $database->createAttribute($cCol, Attribute::string(key: 'bId', required: true));
+        $database->createAttribute($cCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($cCol, Attribute::string(key: 'secret', size: 100, required: true));
+        $database->createAttribute($cCol, Attribute::integer(key: 'score', required: true));
+
+        if ($database->getAdapter()->supports(Capability::Fulltext)) {
+            $database->createIndex($metaCol, Index::fullText(key: 'idx_jh_meta_body', attributes: ['body']));
+        }
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'hm1',
+            'name' => 'Main',
+            'rank' => 1,
+            'peerKey' => 'peer-b',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'hm2',
+            'name' => 'Second',
+            'rank' => 2,
+            'peerKey' => 'peer-missing',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'hm3',
+            'name' => 'Third',
+            'rank' => 1,
+            'peerKey' => 'peer-a',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-10',
+            'mainId' => 'hm1',
+            'score' => 10,
+            'secret' => 'visible',
+            'label' => 'visible-ten',
+            'body' => 'hard-needle visible',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-313',
+            'mainId' => 'hm1',
+            'score' => 313,
+            'secret' => 'visible-313',
+            'label' => 'visible-high',
+            'body' => 'other text',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-20',
+            'mainId' => 'hm2',
+            'score' => 20,
+            'secret' => 'visible-20',
+            'label' => 'visible-m2',
+            'body' => 'm2 text',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-15',
+            'mainId' => 'hm3',
+            'score' => 15,
+            'secret' => 'visible-15',
+            'label' => 'visible-third',
+            'body' => 'third text',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-secret',
+            'mainId' => 'hm1',
+            'score' => 8686,
+            'secret' => 'combo-hard-alpha',
+            'label' => 'hidden-label',
+            'body' => 'hidden-search',
+            '$permissions' => $hidden,
+        ]));
+        $database->createDocument($metaCol, new Document([
+            '$id' => 'hm-meta-orphan',
+            'mainId' => 'missing',
+            'score' => 42,
+            'secret' => 'orphan-visible',
+            'label' => 'orphan',
+            'body' => 'orphan text',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($peerCol, new Document([
+            '$id' => 'peer-a',
+            'mainId' => 'hm1',
+            'label' => 'alpha-one',
+            'score' => 11,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($peerCol, new Document([
+            '$id' => 'peer-b',
+            'mainId' => 'hm2',
+            'label' => 'beta-key',
+            'score' => 22,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($peerCol, new Document([
+            '$id' => 'peer-c',
+            'mainId' => 'hm1',
+            'label' => 'alpha-two',
+            'score' => 33,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($peerCol, new Document([
+            '$id' => 'peer-hidden',
+            'mainId' => 'hm1',
+            'label' => 'combo-hard-alpha',
+            'score' => 8686,
+            'secret' => 'combo-hard-alpha',
+            '$permissions' => $hidden,
+        ]));
+
+        $database->createDocument($aCol, new Document([
+            '$id' => 'ha1',
+            'name' => 'Alpha',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($bCol, new Document([
+            '$id' => 'hb1',
+            'aId' => 'ha1',
+            'mainId' => 'hm1',
+            'label' => 'b-public',
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($bCol, new Document([
+            '$id' => 'hb2',
+            'aId' => 'ha1',
+            'mainId' => 'hm2',
+            'label' => 'b-second',
+            '$permissions' => $readAny,
+        ]));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'hc-open',
+            'bId' => 'hb1',
+            'mainId' => 'hm1',
+            'secret' => 'c-open-token',
+            'score' => 1,
+            '$permissions' => $readAny,
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'hc-hidden',
+            'bId' => 'hb1',
+            'mainId' => 'hm1',
+            'secret' => 'combo-hard-alpha',
+            'score' => 8686,
+            '$permissions' => $hidden,
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'hc-right',
+            'bId' => 'missing',
+            'mainId' => 'missing',
+            'secret' => 'c-right-open',
+            'score' => 7,
+            '$permissions' => $readAny,
+        ]));
+
+        return [$mCol, $metaCol, $peerCol, $aCol, $bCol, $cCol];
+    }
+
+    private function joinHardcoreHasFulltextIndex(Database $database, string $collection): bool
+    {
+        if (! $database->getAdapter()->supports(Capability::Fulltext)) {
+            return false;
+        }
+
+        /** @var array<Document> $indexes */
+        $indexes = $database->getCollection($collection)->indexes;
+        foreach ($indexes as $index) {
+            $type = $index->getAttribute('type');
+            $typeValue = $type instanceof IndexType ? $type->value : $type;
+            if ($typeValue === IndexType::Fulltext->value) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/tests/e2e/Adapter/Scopes/JoinTests.php b/tests/e2e/Adapter/Scopes/JoinTests.php
new file mode 100644
index 0000000000..9147048fc3
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/JoinTests.php
@@ -0,0 +1,5748 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+
+trait JoinTests
+{
+    public function testLeftJoinNoMatchesReturnsAllMainRows(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljnm_p';
+        $rCol = 'ljnm_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        foreach (['Alpha', 'Beta', 'Gamma'] as $name) {
+            $database->createDocument($pCol, new Document([
+                '$id' => strtolower($name),
+                'name' => $name,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($rCol, '$id', 'prod_uid'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(3, $results);
+        foreach ($results as $doc) {
+            $this->assertEquals(1, $doc->getAttribute('cnt'));
+        }
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinPartialMatches(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljpm_p';
+        $rCol = 'ljpm_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        foreach (['p1', 'p2', 'p3'] as $id) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $id,
+                'name' => 'Product ' . $id,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $reviews = [
+            ['prod_uid' => 'p1', 'score' => 5],
+            ['prod_uid' => 'p1', 'score' => 3],
+            ['prod_uid' => 'p1', 'score' => 4],
+            ['prod_uid' => 'p2', 'score' => 2],
+            ['prod_uid' => 'p2', 'score' => 4],
+        ];
+        foreach ($reviews as $r) {
+            $database->createDocument($rCol, new Document(array_merge($r, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($rCol, '$id', 'prod_uid'),
+            Query::count('*', 'cnt'),
+            Query::avg('score', 'avg_score'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(3, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+        $this->assertEquals(3, $mapped['Product p1']->getAttribute('cnt'));
+        $this->assertEqualsWithDelta(4.0, $this->numericAttribute($mapped['Product p1'], 'avg_score'), 0.1);
+        $this->assertEquals(2, $mapped['Product p2']->getAttribute('cnt'));
+        $this->assertEqualsWithDelta(3.0, $this->numericAttribute($mapped['Product p2'], 'avg_score'), 0.1);
+        $this->assertEquals(1, $mapped['Product p3']->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMultipleAggregationAliases(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jma_o';
+        $cCol = 'jma_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        foreach ([100, 200, 300, 400, 500] as $amt) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c1', 'amount' => $amt,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'order_count'),
+            Query::sum('amount', 'total_amount'),
+            Query::avg('amount', 'avg_amount'),
+            Query::min('amount', 'min_amount'),
+            Query::max('amount', 'max_amount'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(5, $results[0]->getAttribute('order_count'));
+        $this->assertEquals(1500, $results[0]->getAttribute('total_amount'));
+        $this->assertEqualsWithDelta(300.0, $this->numericAttribute($results[0], 'avg_amount'), 0.1);
+        $this->assertEquals(100, $results[0]->getAttribute('min_amount'));
+        $this->assertEquals(500, $results[0]->getAttribute('max_amount'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMultipleGroupByColumns(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jmg_o';
+        $cCol = 'jmg_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 200],
+            ['cust_uid' => 'c1', 'status' => 'pending', 'amount' => 50],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 300],
+            ['cust_uid' => 'c2', 'status' => 'pending', 'amount' => 75],
+            ['cust_uid' => 'c2', 'status' => 'pending', 'amount' => 25],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid', 'status']),
+        ]);
+
+        $this->assertCount(4, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $custUid = $doc->getAttribute('cust_uid');
+            $status = $doc->getAttribute('status');
+            $this->assertIsString($custUid);
+            $this->assertIsString($status);
+            $key = $custUid . '_' . $status;
+            $mapped[$key] = $doc;
+        }
+        $this->assertEquals(2, $mapped['c1_done']->getAttribute('cnt'));
+        $this->assertEquals(300, $mapped['c1_done']->getAttribute('total'));
+        $this->assertEquals(1, $mapped['c1_pending']->getAttribute('cnt'));
+        $this->assertEquals(50, $mapped['c1_pending']->getAttribute('total'));
+        $this->assertEquals(1, $mapped['c2_done']->getAttribute('cnt'));
+        $this->assertEquals(300, $mapped['c2_done']->getAttribute('total'));
+        $this->assertEquals(2, $mapped['c2_pending']->getAttribute('cnt'));
+        $this->assertEquals(100, $mapped['c2_pending']->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithHavingOnCount(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhc_o';
+        $cCol = 'jhc_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 20],
+            ['cust_uid' => 'c2', 'amount' => 30],
+            ['cust_uid' => 'c3', 'amount' => 40],
+            ['cust_uid' => 'c3', 'amount' => 50],
+            ['cust_uid' => 'c3', 'amount' => 60],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::greaterThan('cnt', 1)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c2', $ids);
+        $this->assertContains('c3', $ids);
+        $this->assertNotContains('c1', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithHavingOnAvg(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jha_o';
+        $cCol = 'jha_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c1', 'amount' => 20],
+            ['cust_uid' => 'c2', 'amount' => 500],
+            ['cust_uid' => 'c2', 'amount' => 600],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::avg('amount', 'avg_amt'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::greaterThan('avg_amt', 100)]),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('c2', $results[0]->getAttribute('cust_uid'));
+        $avgAmt = $results[0]->getAttribute('avg_amt');
+        $this->assertIsNumeric($avgAmt);
+        $this->assertEqualsWithDelta(550.0, (float) $avgAmt, 0.1);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithHavingOnSum(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhs_o';
+        $cCol = 'jhs_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 50],
+            ['cust_uid' => 'c2', 'amount' => 300],
+            ['cust_uid' => 'c2', 'amount' => 400],
+            ['cust_uid' => 'c3', 'amount' => 100],
+            ['cust_uid' => 'c3', 'amount' => 100],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::greaterThan('total', 250)]),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('c2', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(700, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithHavingBetween(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhb_o';
+        $cCol = 'jhb_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 100],
+            ['cust_uid' => 'c2', 'amount' => 200],
+            ['cust_uid' => 'c3', 'amount' => 500],
+            ['cust_uid' => 'c3', 'amount' => 600],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::between('total', 100, 500)]),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('c2', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(300, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinCountDistinct(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jcd_o';
+        $cCol = 'jcd_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'product', size: 50, required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'product' => 'A'],
+            ['cust_uid' => 'c1', 'product' => 'A'],
+            ['cust_uid' => 'c1', 'product' => 'B'],
+            ['cust_uid' => 'c2', 'product' => 'C'],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::countDistinct('product', 'uniq_prod'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('uniq_prod'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMinMax(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jmm_o';
+        $cCol = 'jmm_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c1', 'amount' => 50],
+            ['cust_uid' => 'c1', 'amount' => 30],
+            ['cust_uid' => 'c2', 'amount' => 200],
+            ['cust_uid' => 'c2', 'amount' => 100],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::min('amount', 'min_amt'),
+            Query::max('amount', 'max_amt'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(10, $mapped['c1']->getAttribute('min_amt'));
+        $this->assertEquals(50, $mapped['c1']->getAttribute('max_amt'));
+        $this->assertEquals(100, $mapped['c2']->getAttribute('min_amt'));
+        $this->assertEquals(200, $mapped['c2']->getAttribute('max_amt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinFilterOnMainTable(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jfm_o';
+        $cCol = 'jfm_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'open', 'amount' => 200],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 300],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 400],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['done']),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(1, $mapped['c1']->getAttribute('cnt'));
+        $this->assertEquals(100, $mapped['c1']->getAttribute('total'));
+        $this->assertEquals(2, $mapped['c2']->getAttribute('cnt'));
+        $this->assertEquals(700, $mapped['c2']->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinBetweenFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jbf_o';
+        $cCol = 'jbf_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        foreach ([50, 150, 250, 350, 450] as $amt) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c1', 'amount' => $amt,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::between('amount', 100, 300),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(2, $results[0]->getAttribute('cnt'));
+        $this->assertEquals(400, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinGreaterLessThanFilters(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jgl_o';
+        $cCol = 'jgl_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        foreach ([10, 20, 30, 40, 50] as $amt) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c1', 'amount' => $amt,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::greaterThan('amount', 15),
+            Query::lessThanEqual('amount', 40),
+            Query::count('*', 'cnt'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(3, $results[0]->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinEmptyResultSet(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jer_o';
+        $cCol = 'jer_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->createDocument($oCol, new Document([
+            'cust_uid' => 'nonexistent', 'amount' => 100,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(0, $results[0]->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinFilterYieldsNoResults(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jfnr_o';
+        $cCol = 'jfnr_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'cust_uid' => 'c1', 'status' => 'done', 'amount' => 100,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['ghost']),
+            Query::count('*', 'cnt'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(0, $results[0]->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinSumNullRightSide(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljsn_p';
+        $oCol = 'ljsn_o';
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1', 'name' => 'WithOrders',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2', 'name' => 'NoOrders',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p1', 'amount' => 100,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p1', 'amount' => 200,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($oCol, '$id', 'prod_uid'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc;
+        }
+        $this->assertEquals(300, $mapped['WithOrders']->getAttribute('total'));
+        $noOrderTotal = $mapped['NoOrders']->getAttribute('total');
+        $this->assertTrue($noOrderTotal === null || $noOrderTotal === 0 || $noOrderTotal === 0.0);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMultipleFilterTypes(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jmft_o';
+        $cCol = 'jmft_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 500],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 600],
+            ['cust_uid' => 'c1', 'status' => 'open', 'amount' => 100],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 50],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 800],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 900],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['done']),
+            Query::greaterThan('amount', 100),
+            Query::sum('amount', 'total'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::greaterThan('total', 500)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c1', $ids);
+        $this->assertContains('c3', $ids);
+        $this->assertNotContains('c2', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinLargeDataset(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jld_o';
+        $cCol = 'jld_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        for ($i = 1; $i <= 10; $i++) {
+            $cid = 'c' . $i;
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $i,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+
+            for ($j = 1; $j <= 10; $j++) {
+                $database->createDocument($oCol, new Document([
+                    'cust_uid' => $cid, 'amount' => $j * 10,
+                    '$permissions' => [Permission::read(Role::any())],
+                ]));
+            }
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(10, $results);
+        foreach ($results as $doc) {
+            $this->assertEquals(10, $doc->getAttribute('cnt'));
+            $this->assertEquals(550, $doc->getAttribute('total'));
+        }
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinNotEqualFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jne_o';
+        $cCol = 'jne_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 200],
+            ['cust_uid' => 'c1', 'status' => 'cancel', 'amount' => 50],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::notEqual('status', 'cancel'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(2, $results[0]->getAttribute('cnt'));
+        $this->assertEquals(300, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinStartsWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jsw_o';
+        $cCol = 'jsw_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'tag', size: 50, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $orders = [
+            ['cust_uid' => 'c1', 'tag' => 'promo_spring', 'amount' => 100],
+            ['cust_uid' => 'c1', 'tag' => 'promo_fall', 'amount' => 200],
+            ['cust_uid' => 'c1', 'tag' => 'regular', 'amount' => 50],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::startsWith('tag', 'promo'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(2, $results[0]->getAttribute('cnt'));
+        $this->assertEquals(300, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinEqualMultipleValues(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jemv_o';
+        $cCol = 'jemv_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'open', 'amount' => 200],
+            ['cust_uid' => 'c1', 'status' => 'cancel', 'amount' => 50],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 300],
+            ['cust_uid' => 'c2', 'status' => 'cancel', 'amount' => 25],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['done', 'open']),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(2, $mapped['c1']->getAttribute('cnt'));
+        $this->assertEquals(300, $mapped['c1']->getAttribute('total'));
+        $this->assertEquals(1, $mapped['c2']->getAttribute('cnt'));
+        $this->assertEquals(300, $mapped['c2']->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinGroupByHavingLessThan(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jghl_o';
+        $cCol = 'jghl_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 500],
+            ['cust_uid' => 'c2', 'amount' => 600],
+            ['cust_uid' => 'c3', 'amount' => 20],
+            ['cust_uid' => 'c3', 'amount' => 30],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::lessThan('total', 100)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c1', $ids);
+        $this->assertContains('c3', $ids);
+        $this->assertNotContains('c2', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinHavingCountZero(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljhz_p';
+        $oCol = 'ljhz_o';
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['p1', 'p2', 'p3'] as $pid) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $pid, 'name' => 'Product ' . $pid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p1', 'amount' => 100,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p1', 'amount' => 200,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($oCol, '$id', 'prod_uid'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['name']),
+            Query::having([Query::greaterThan('cnt', 1)]),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('Product p1', $results[0]->getAttribute('name'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinGroupByAllAggregations(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jgba_o';
+        $cCol = 'jgba_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 100],
+            ['cust_uid' => 'c1', 'amount' => 200],
+            ['cust_uid' => 'c1', 'amount' => 300],
+            ['cust_uid' => 'c2', 'amount' => 50],
+            ['cust_uid' => 'c2', 'amount' => 150],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::avg('amount', 'avg_amt'),
+            Query::min('amount', 'min_amt'),
+            Query::max('amount', 'max_amt'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['c1']->getAttribute('cnt'));
+        $this->assertEquals(600, $mapped['c1']->getAttribute('total'));
+        $c1Avg = $mapped['c1']->getAttribute('avg_amt');
+        $this->assertIsNumeric($c1Avg);
+        $this->assertEqualsWithDelta(200.0, (float) $c1Avg, 0.1);
+        $this->assertEquals(100, $mapped['c1']->getAttribute('min_amt'));
+        $this->assertEquals(300, $mapped['c1']->getAttribute('max_amt'));
+
+        $this->assertEquals(2, $mapped['c2']->getAttribute('cnt'));
+        $this->assertEquals(200, $mapped['c2']->getAttribute('total'));
+        $c2Avg = $mapped['c2']->getAttribute('avg_amt');
+        $this->assertIsNumeric($c2Avg);
+        $this->assertEqualsWithDelta(100.0, (float) $c2Avg, 0.1);
+        $this->assertEquals(50, $mapped['c2']->getAttribute('min_amt'));
+        $this->assertEquals(150, $mapped['c2']->getAttribute('max_amt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinSingleRowPerGroup(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jsr_o';
+        $cCol = 'jsr_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        foreach (['c1', 'c2', 'c3'] as $i => $cid) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => $cid, 'amount' => ($i + 1) * 100,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(3, $results);
+        foreach ($results as $doc) {
+            $this->assertEquals(1, $doc->getAttribute('cnt'));
+        }
+
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(100, $mapped['c1']->getAttribute('total'));
+        $this->assertEquals(200, $mapped['c2']->getAttribute('total'));
+        $this->assertEquals(300, $mapped['c3']->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    /**
+     * @return array<string, array{string, int}>
+     */
+    public static function joinTypeProvider(): array
+    {
+        return [
+            'inner join' => ['join', 2],
+            'left join' => ['leftJoin', 3],
+        ];
+    }
+
+    #[DataProvider('joinTypeProvider')]
+    public function testJoinTypeCountsCorrectly(string $joinMethod, int $expectedGroups): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'jtc_p_'.$joinMethod;
+        $oCol = 'jtc_o_'.$joinMethod;
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'qty', required: true));
+
+        foreach (['p1', 'p2', 'p3'] as $pid) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $pid, 'name' => 'Product ' . $pid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p1', 'qty' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'p2', 'qty' => 3,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $joinQuery = match ($joinMethod) {
+            'join' => Query::join($oCol, '$id', 'prod_uid'),
+            'leftJoin' => Query::leftJoin($oCol, '$id', 'prod_uid'),
+            default => throw new \InvalidArgumentException('Unknown join method: '.$joinMethod),
+        };
+
+        $results = $database->find($pCol, [
+            $joinQuery,
+            Query::count('*', 'cnt'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount($expectedGroups, $results);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    /**
+     * @return array<string, array{string, string, int|float}>
+     */
+    public static function joinAggregationTypeProvider(): array
+    {
+        return [
+            'count' => ['count', '*', 10],
+            'sum' => ['sum', 'amount', 5500],
+            'avg' => ['avg', 'amount', 550.0],
+            'min' => ['min', 'amount', 100],
+            'max' => ['max', 'amount', 1000],
+        ];
+    }
+
+    #[DataProvider('joinAggregationTypeProvider')]
+    public function testJoinWithDifferentAggTypes(string $aggMethod, string $attribute, int|float $expected): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jat_o_'.$aggMethod;
+        $cCol = 'jat_c_'.$aggMethod;
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        for ($i = 1; $i <= 10; $i++) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c1', 'amount' => $i * 100,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $aggQuery = match ($aggMethod) {
+            'count' => Query::count($attribute, 'result'),
+            'sum' => Query::sum($attribute, 'result'),
+            'avg' => Query::avg($attribute, 'result'),
+            'min' => Query::min($attribute, 'result'),
+            'max' => Query::max($attribute, 'result'),
+            default => throw new \InvalidArgumentException('Unknown aggregation method: '.$aggMethod),
+        };
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            $aggQuery,
+        ]);
+
+        $this->assertCount(1, $results);
+        if ($aggMethod === 'avg') {
+            $result = $results[0]->getAttribute('result');
+            $this->assertIsNumeric($result);
+            $this->assertEqualsWithDelta($expected, (float) $result, 0.1);
+        } else {
+            $this->assertEquals($expected, $results[0]->getAttribute('result'));
+        }
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    /**
+     * @return array<string, array{string, string, int|float, int}>
+     */
+    public static function joinHavingOperatorProvider(): array
+    {
+        return [
+            'gt 2' => ['greaterThan', 'cnt', 2, 2],
+            'gte 3' => ['greaterThanEqual', 'cnt', 3, 2],
+            'lt 4' => ['lessThan', 'cnt', 4, 2],
+            'lte 3' => ['lessThanEqual', 'cnt', 3, 2],
+        ];
+    }
+
+    #[DataProvider('joinHavingOperatorProvider')]
+    public function testJoinHavingOperators(string $operator, string $alias, int|float $threshold, int $expectedGroups): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jho_o_'.$operator;
+        $cCol = 'jho_c_'.$operator;
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $database->createDocument($oCol, new Document([
+            'cust_uid' => 'c1', 'amount' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        for ($i = 0; $i < 3; $i++) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c2', 'amount' => 20,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        for ($i = 0; $i < 5; $i++) {
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => 'c3', 'amount' => 30,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $havingQuery = match ($operator) {
+            'greaterThan' => Query::greaterThan($alias, $threshold),
+            'greaterThanEqual' => Query::greaterThanEqual($alias, $threshold),
+            'lessThan' => Query::lessThan($alias, $threshold),
+            'lessThanEqual' => Query::lessThanEqual($alias, $threshold),
+            default => throw new \InvalidArgumentException('Unknown operator: '.$operator),
+        };
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', $alias),
+            Query::groupBy(['cust_uid']),
+            Query::having([$havingQuery]),
+        ]);
+
+        $this->assertCount($expectedGroups, $results);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinOrderByAggregation(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'joa_o';
+        $cCol = 'joa_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 20],
+            ['cust_uid' => 'c2', 'amount' => 30],
+            ['cust_uid' => 'c2', 'amount' => 40],
+            ['cust_uid' => 'c3', 'amount' => 50],
+            ['cust_uid' => 'c3', 'amount' => 60],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::orderDesc('total'),
+        ]);
+
+        $this->assertCount(3, $results);
+        $totals = array_map(fn (Document $d) => $this->intAttribute($d, 'total'), $results);
+        $this->assertEquals([110, 90, 10], $totals);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithLimit(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jwl_o';
+        $cCol = 'jwl_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        for ($i = 1; $i <= 5; $i++) {
+            $cid = 'c' . $i;
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $i,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => $cid, 'amount' => $i * 100,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::orderDesc('total'),
+            Query::limit(2),
+        ]);
+
+        $this->assertCount(2, $results);
+        $this->assertEquals(500, $this->intAttribute($results[0], 'total'));
+        $this->assertEquals(400, $this->intAttribute($results[1], 'total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithLimitAndOffset(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jlo_o';
+        $cCol = 'jlo_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        for ($i = 1; $i <= 5; $i++) {
+            $cid = 'c' . $i;
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $i,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => $cid, 'amount' => $i * 100,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::orderDesc('total'),
+            Query::limit(2),
+            Query::offset(1),
+        ]);
+
+        $this->assertCount(2, $results);
+        $this->assertEquals(400, $this->intAttribute($results[0], 'total'));
+        $this->assertEquals(300, $this->intAttribute($results[1], 'total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMultipleHavingConditions(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jmhc_o';
+        $cCol = 'jmhc_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3', 'c4'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 100],
+            ['cust_uid' => 'c2', 'amount' => 200],
+            ['cust_uid' => 'c3', 'amount' => 50],
+            ['cust_uid' => 'c3', 'amount' => 50],
+            ['cust_uid' => 'c3', 'amount' => 50],
+            ['cust_uid' => 'c4', 'amount' => 500],
+            ['cust_uid' => 'c4', 'amount' => 600],
+            ['cust_uid' => 'c4', 'amount' => 700],
+            ['cust_uid' => 'c4', 'amount' => 800],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // HAVING count >= 2 AND sum > 200 → c2 (cnt=2, sum=300) and c4 (cnt=4, sum=2600)
+        // c1 excluded (cnt=1), c3 excluded (cnt=3, sum=150 < 200)
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([
+                Query::greaterThanEqual('cnt', 2),
+                Query::greaterThan('total', 200),
+            ]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c2', $ids);
+        $this->assertContains('c4', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinHavingWithEqual(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhe_o';
+        $cCol = 'jhe_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 20],
+            ['cust_uid' => 'c2', 'amount' => 30],
+            ['cust_uid' => 'c3', 'amount' => 40],
+            ['cust_uid' => 'c3', 'amount' => 50],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::equal('cnt', [2])]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c2', $ids);
+        $this->assertContains('c3', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinEmptyMainTable(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jem_o';
+        $cCol = 'jem_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        // Main table (orders) is empty
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(0, $results[0]->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinOrderByGroupedColumn(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jogc_o';
+        $cCol = 'jogc_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['alpha', 'beta', 'gamma'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => ucfirst($cid),
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($oCol, new Document([
+                'cust_uid' => $cid, 'amount' => 100,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['cust_uid']),
+            Query::orderDesc('cust_uid'),
+        ]);
+
+        $this->assertCount(3, $results);
+        $custIds = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertEquals(['gamma', 'beta', 'alpha'], $custIds);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testTwoTableJoinFromMainTable(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        // Main table: orders, referencing both customers and products
+        $cCol = 'ttj_c';
+        $pCol = 'ttj_p';
+        $oCol = 'ttj_o';
+        $cols = [$cCol, $pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'title', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Alice',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c2', 'name' => 'Bob',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1', 'title' => 'Widget',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2', 'title' => 'Gadget',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $orders = [
+            ['cust_uid' => 'c1', 'prod_uid' => 'p1', 'amount' => 100],
+            ['cust_uid' => 'c1', 'prod_uid' => 'p1', 'amount' => 200],
+            ['cust_uid' => 'c1', 'prod_uid' => 'p2', 'amount' => 300],
+            ['cust_uid' => 'c2', 'prod_uid' => 'p1', 'amount' => 150],
+            ['cust_uid' => 'c2', 'prod_uid' => 'p2', 'amount' => 250],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Join both customers and products from orders
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::join($pCol, 'prod_uid', '$id'),
+            Query::count('*', 'order_cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(3, $mapped['c1']->getAttribute('order_cnt'));
+        $this->assertEquals(600, $this->intAttribute($mapped['c1'], 'total'));
+        $this->assertEquals(2, $mapped['c2']->getAttribute('order_cnt'));
+        $this->assertEquals(400, $this->intAttribute($mapped['c2'], 'total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinHavingNotBetween(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhnb_o';
+        $cCol = 'jhnb_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 100],
+            ['cust_uid' => 'c2', 'amount' => 200],
+            ['cust_uid' => 'c3', 'amount' => 500],
+            ['cust_uid' => 'c3', 'amount' => 600],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Sums: c1=10, c2=300, c3=1100
+        // NOT BETWEEN 50 AND 500 → c1 (10) and c3 (1100)
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::notBetween('total', 50, 500)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $ids = array_map(fn ($d) => $d->getAttribute('cust_uid'), $results);
+        $this->assertContains('c1', $ids);
+        $this->assertContains('c3', $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithFilterAndOrder(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jfo_o';
+        $cCol = 'jfo_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 500],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 900],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 200],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 300],
+            ['cust_uid' => 'c3', 'status' => 'open', 'amount' => 10000],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Filter done only, group by customer, order by total ascending
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['done']),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::orderAsc('total'),
+        ]);
+
+        $this->assertCount(3, $results);
+        $totals = array_map(fn (Document $d) => $this->intAttribute($d, 'total'), $results);
+        $this->assertEquals([500, 600, 900], $totals);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinHavingNotEqual(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhne_o';
+        $cCol = 'jhne_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'amount' => 10],
+            ['cust_uid' => 'c2', 'amount' => 20],
+            ['cust_uid' => 'c2', 'amount' => 30],
+            ['cust_uid' => 'c3', 'amount' => 40],
+            ['cust_uid' => 'c3', 'amount' => 50],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Counts: c1=1, c2=2, c3=2. HAVING count != 2 → c1 only
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::notEqual('cnt', 2)]),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('c1', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(1, $results[0]->getAttribute('cnt'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinAllUnmatched(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljau_p';
+        $oCol = 'ljau_o';
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'qty', required: true));
+
+        foreach (['p1', 'p2'] as $pid) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $pid, 'name' => 'Product ' . $pid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        // Orders reference non-existent products
+        $database->createDocument($oCol, new Document([
+            'prod_uid' => 'nonexistent', 'qty' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($oCol, '$id', 'prod_uid'),
+            Query::count('*', 'cnt'),
+            Query::groupBy(['name']),
+        ]);
+
+        $this->assertCount(2, $results);
+        foreach ($results as $doc) {
+            $this->assertEquals(1, $doc->getAttribute('cnt'));
+        }
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinSameTableDifferentFilters(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jstdf_o';
+        $cCol = 'jstdf_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'category' => 'electronics', 'amount' => 500],
+            ['cust_uid' => 'c1', 'category' => 'books', 'amount' => 20],
+            ['cust_uid' => 'c1', 'category' => 'books', 'amount' => 30],
+            ['cust_uid' => 'c2', 'category' => 'electronics', 'amount' => 1000],
+            ['cust_uid' => 'c2', 'category' => 'electronics', 'amount' => 200],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Filter electronics only, group by customer
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('category', ['electronics']),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::orderDesc('total'),
+        ]);
+
+        $this->assertCount(2, $results);
+        $this->assertEquals('c2', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(1200, $this->intAttribute($results[0], 'total'));
+        $this->assertEquals('c1', $results[1]->getAttribute('cust_uid'));
+        $this->assertEquals(500, $this->intAttribute($results[1], 'total'));
+
+        // Now books only
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('category', ['books']),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals('c1', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(50, $this->intAttribute($results[0], 'total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinGroupByMultipleColumnsWithHaving(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jgmh_o';
+        $cCol = 'jgmh_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 200],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 300],
+            ['cust_uid' => 'c1', 'status' => 'open', 'amount' => 50],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 400],
+            ['cust_uid' => 'c2', 'status' => 'open', 'amount' => 25],
+            ['cust_uid' => 'c2', 'status' => 'open', 'amount' => 75],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // GROUP BY cust_uid, status with HAVING count >= 2
+        // c1/done (3), c1/open (1), c2/done (1), c2/open (2)
+        // Should return c1/done and c2/open
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid', 'status']),
+            Query::having([Query::greaterThanEqual('cnt', 2)]),
+        ]);
+
+        $this->assertCount(2, $results);
+        $keys = array_map(function (Document $document): string {
+            $custUid = $document->getAttribute('cust_uid');
+            $status = $document->getAttribute('status');
+            $this->assertIsString($custUid);
+            $this->assertIsString($status);
+
+            return $custUid . '_' . $status;
+        }, $results);
+        $this->assertContains('c1_done', $keys);
+        $this->assertContains('c2_open', $keys);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinCountDistinctGrouped(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jcdg_o';
+        $cCol = 'jcdg_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'product', size: 50, required: true));
+
+        foreach (['c1', 'c2'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'product' => 'A'],
+            ['cust_uid' => 'c1', 'product' => 'A'],
+            ['cust_uid' => 'c1', 'product' => 'B'],
+            ['cust_uid' => 'c1', 'product' => 'C'],
+            ['cust_uid' => 'c2', 'product' => 'A'],
+            ['cust_uid' => 'c2', 'product' => 'A'],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::countDistinct('product', 'unique_products'),
+            Query::groupBy(['cust_uid']),
+        ]);
+
+        $this->assertCount(2, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $cust_uid = $doc->getAttribute('cust_uid');
+            $this->assertIsString($cust_uid);
+            $mapped[$cust_uid] = $doc;
+        }
+        $this->assertEquals(3, $mapped['c1']->getAttribute('unique_products'));
+        $this->assertEquals(1, $mapped['c2']->getAttribute('unique_products'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinHavingOnSumWithFilter(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhsf_o';
+        $cCol = 'jhsf_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'status', size: 20, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $orders = [
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 100],
+            ['cust_uid' => 'c1', 'status' => 'done', 'amount' => 200],
+            ['cust_uid' => 'c1', 'status' => 'open', 'amount' => 9999],
+            ['cust_uid' => 'c2', 'status' => 'done', 'amount' => 50],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 400],
+            ['cust_uid' => 'c3', 'status' => 'done', 'amount' => 500],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        // Filter to 'done' only, then HAVING sum > 200
+        // c1 done sum=300, c2 done sum=50, c3 done sum=900
+        // → c1 and c3 match
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::equal('status', ['done']),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::greaterThan('total', 200)]),
+            Query::orderAsc('total'),
+        ]);
+
+        $this->assertCount(2, $results);
+        $this->assertEquals('c1', $results[0]->getAttribute('cust_uid'));
+        $this->assertEquals(300, $this->intAttribute($results[0], 'total'));
+        $this->assertEquals('c3', $results[1]->getAttribute('cust_uid'));
+        $this->assertEquals(900, $this->intAttribute($results[1], 'total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinGroupByWithOrderAndLimit(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljgl_p';
+        $oCol = 'ljgl_o';
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'qty', required: true));
+
+        for ($i = 1; $i <= 5; $i++) {
+            $pid = 'p' . $i;
+            $database->createDocument($pCol, new Document([
+                '$id' => $pid, 'name' => 'Product ' . $i,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            for ($j = 0; $j < $i; $j++) {
+                $database->createDocument($oCol, new Document([
+                    'prod_uid' => $pid, 'qty' => 10,
+                    '$permissions' => [Permission::read(Role::any())],
+                ]));
+            }
+        }
+
+        // Get top 3 products by order count, descending
+        $results = $database->find($pCol, [
+            Query::leftJoin($oCol, '$id', 'prod_uid'),
+            Query::count('*', 'order_cnt'),
+            Query::groupBy(['name']),
+            Query::orderDesc('order_cnt'),
+            Query::limit(3),
+        ]);
+
+        $this->assertCount(3, $results);
+        $counts = [];
+        foreach ($results as $document) {
+            $count = $document->getAttribute('order_cnt');
+            $this->assertIsNumeric($count);
+            $counts[] = (int) $count;
+        }
+        $this->assertEquals([5, 4, 3], $counts);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinWithEndsWith(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jew_o';
+        $cCol = 'jew_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::string(key: 'tag', size: 50, required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1', 'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $orders = [
+            ['cust_uid' => 'c1', 'tag' => 'order_express', 'amount' => 100],
+            ['cust_uid' => 'c1', 'tag' => 'order_express', 'amount' => 200],
+            ['cust_uid' => 'c1', 'tag' => 'order_standard', 'amount' => 50],
+        ];
+        foreach ($orders as $o) {
+            $database->createDocument($oCol, new Document(array_merge($o, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::endsWith('tag', 'express'),
+            Query::count('*', 'cnt'),
+            Query::sum('amount', 'total'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertEquals(2, $results[0]->getAttribute('cnt'));
+        $this->assertEquals(300, $results[0]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinHavingLessThanEqual(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $oCol = 'jhle_o';
+        $cCol = 'jhle_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        foreach (['c1', 'c2', 'c3'] as $cid) {
+            $database->createDocument($cCol, new Document([
+                '$id' => $cid, 'name' => 'Customer ' . $cid,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        // c1: sum=100, c2: sum=200, c3: sum=300
+        foreach (['c1' => [100], 'c2' => [100, 100], 'c3' => [100, 100, 100]] as $cid => $amounts) {
+            foreach ($amounts as $amt) {
+                $database->createDocument($oCol, new Document([
+                    'cust_uid' => $cid, 'amount' => $amt,
+                    '$permissions' => [Permission::read(Role::any())],
+                ]));
+            }
+        }
+
+        // HAVING sum <= 200 → c1 (100) and c2 (200)
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            Query::sum('amount', 'total'),
+            Query::groupBy(['cust_uid']),
+            Query::having([Query::lessThanEqual('total', 200)]),
+            Query::orderAsc('total'),
+        ]);
+
+        $this->assertCount(2, $results);
+        $this->assertEquals('c1', $results[0]->getAttribute('cust_uid'));
+        $c1Total = $results[0]->getAttribute('total');
+        $this->assertIsNumeric($c1Total);
+        $this->assertEquals(100, (int) $c1Total);
+        $this->assertEquals('c2', $results[1]->getAttribute('cust_uid'));
+        $c2Total = $results[1]->getAttribute('total');
+        $this->assertIsNumeric($c2Total);
+        $this->assertEquals(200, (int) $c2Total);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testRightJoinIncludesUnmatchedRightRows(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_rj_p';
+        $rCol = 't8_rj_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->getAuthorization()->skip(fn () => $database->find($pCol, [
+            Query::rightJoin($rCol, '$id', 'prod_uid'),
+            Query::select(['name']),
+        ]));
+
+        $this->assertCount(2, $results);
+        $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+        \sort($ids);
+        $this->assertSame(['', 'p1'], $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testCrossJoinCartesianProduct(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $aCol = 't8_xj_a';
+        $bCol = 't8_xj_b';
+        $cols = [$aCol, $bCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $aCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($aCol, Attribute::string(key: 'label', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $bCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($bCol, Attribute::string(key: 'tag', size: 100, required: true));
+
+        foreach (['a1', 'a2', 'a3'] as $id) {
+            $database->createDocument($aCol, new Document([
+                '$id' => $id,
+                'label' => $id,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+        foreach (['b1', 'b2'] as $id) {
+            $database->createDocument($bCol, new Document([
+                '$id' => $id,
+                'tag' => $id,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($aCol, [
+            Query::crossJoin($bCol),
+        ]);
+
+        $this->assertCount(6, $results);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testFullOuterJoinIncludesBothUnmatched(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_fo_p';
+        $rCol = 't8_fo_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->getAuthorization()->skip(fn () => $database->find($pCol, [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            Query::select(['name']),
+        ]));
+
+        $this->assertSame(3, \count($results));
+        $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+        \sort($ids);
+        $this->assertSame(['', 'p1', 'p2'], $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testFullOuterJoinSelectDoesNotCollapseOneToMany(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_fo_1n_p';
+        $rCol = 't8_fo_1n_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 3,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->getAuthorization()->skip(fn () => $database->find($pCol, [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            Query::select(['name']),
+        ]));
+
+        $this->assertSame(4, \count($results));
+        $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+        \sort($ids);
+        $this->assertSame(['', 'p1', 'p1', 'p2'], $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testNaturalJoinThrowsQueryException(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_nj_p';
+        $rCol = 't8_nj_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        try {
+            $database->find($pCol, [
+                Query::naturalJoin($rCol),
+            ]);
+            $this->fail('Expected QueryException for natural join');
+        } catch (QueryException $exception) {
+            $this->assertStringContainsString('Natural joins are not supported', $exception->getMessage());
+        } finally {
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testJoinOperatorGreaterThan(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $lCol = 't8_jgt_l';
+        $rCol = 't8_jgt_r';
+        $cols = [$lCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $lCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($lCol, Attribute::integer(key: 'value', required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::integer(key: 'threshold', required: true));
+
+        foreach ([10, 20, 30] as $value) {
+            $database->createDocument($lCol, new Document([
+                'value' => $value,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+        foreach ([15, 25] as $threshold) {
+            $database->createDocument($rCol, new Document([
+                'threshold' => $threshold,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $results = $database->find($lCol, [
+            Query::join($rCol, 'value', 'threshold', '>'),
+        ]);
+
+        $this->assertCount(3, $results);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinPreservesUserAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $cCol = 't8_jua_c';
+        $oCol = 't8_jua_o';
+        $cols = [$cCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1',
+            'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'cust_uid' => 'c1',
+            'amount' => 150,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($cCol, [
+            Query::join($oCol, '$id', 'cust_uid', '=', 'ord'),
+            Query::select(['name', 'ord.amount']),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertSame('c1', $results[0]->getId());
+        $this->assertSame('Customer 1', $results[0]->getAttribute('name'));
+        $amount = $results[0]->getAttribute('amount');
+        $this->assertIsNumeric($amount);
+        $this->assertSame(150, (int) $amount);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testChainedJoinsQualifySecondJoinLeft(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $cCol = 't8_jch_c';
+        $oCol = 't8_jch_o';
+        $iCol = 't8_jch_i';
+        $cols = [$cCol, $oCol, $iCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createCollection(new Collection(id: $iCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($iCol, Attribute::string(key: 'order_uid', required: true));
+        $database->createAttribute($iCol, Attribute::string(key: 'sku', size: 100, required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1',
+            'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            '$id' => 'o1',
+            'cust_uid' => 'c1',
+            'amount' => 150,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($iCol, new Document([
+            'order_uid' => 'o1',
+            'sku' => 'widget',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($cCol, [
+            Query::join($oCol, '$id', 'cust_uid', '=', 'ord'),
+            Query::join($iCol, 'ord.$id', 'order_uid', '=', 'itm'),
+            Query::select(['name', 'ord.amount', 'itm.sku']),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertSame('c1', $results[0]->getId());
+        $chainedAmount = $results[0]->getAttribute('amount');
+        $this->assertIsNumeric($chainedAmount);
+        $this->assertSame(150, (int) $chainedAmount);
+        $this->assertSame('widget', $results[0]->getAttribute('sku'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testSelectJoinedColumnByAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $cCol = 't8_jsa_c';
+        $oCol = 't8_jsa_o';
+        $cols = [$cCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'cust_uid', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c1',
+            'name' => 'Customer 1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            'cust_uid' => 'c1',
+            'amount' => 275,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($cCol, [
+            Query::select(['name', 'ord.amount']),
+            Query::join($oCol, '$id', 'cust_uid', '=', 'ord'),
+        ]);
+
+        $this->assertCount(1, $results);
+        $this->assertSame('Customer 1', $results[0]->getAttribute('name'));
+        $selectedAmount = $results[0]->getAttribute('amount');
+        $this->assertIsNumeric($selectedAmount);
+        $this->assertSame(275, (int) $selectedAmount);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testRightJoinUnmatchedRowSurvivesDocumentSecurity(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_rjds_p';
+        $rCol = 't8_rjds_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::rightJoin($rCol, '$id', 'prod_uid'),
+            Query::select(['name']),
+        ]);
+
+        $this->assertSame(2, \count($results));
+        $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+        \sort($ids);
+        $this->assertSame(['', 'p1'], $ids);
+
+        $unmatched = null;
+        foreach ($results as $document) {
+            if ($document->getId() === '') {
+                $unmatched = $document;
+                break;
+            }
+        }
+        $this->assertNotNull($unmatched);
+        $this->assertTrue($unmatched->getAttribute('name') === null || $unmatched->getAttribute('name') === '');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testFullOuterJoinUnmatchedRowsSurviveDocumentSecurity(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_fods_p';
+        $rCol = 't8_fods_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            Query::select(['name']),
+        ]);
+
+        $this->assertSame(3, \count($results));
+        $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+        \sort($ids);
+        $this->assertSame(['', 'p1', 'p2'], $ids);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testSelfJoinAppliesPermissionToEachAlias(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $col = 't8_sjacl';
+        $cols = [$col];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $col, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($col, Attribute::string(key: 'payload', size: 100, required: true));
+        $database->createAttribute($col, Attribute::string(key: 'code', size: 100, required: true));
+        $database->createAttribute($col, Attribute::string(key: 'tag', size: 50, required: true));
+
+        $database->createDocument($col, new Document([
+            '$id' => 'open',
+            'payload' => 'open-payload',
+            'code' => 'open-code',
+            'tag' => 'shared',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($col, new Document([
+            '$id' => 'secret',
+            'payload' => 'secret-payload',
+            'code' => 'secret-code',
+            'tag' => 'shared',
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        $authorization->addRole(Role::any()->toString());
+
+        try {
+            $results = $database->find($col, [
+                Query::join($col, 'tag', 'tag', '=', 'visible'),
+                Query::join($col, 'tag', 'tag', '=', 'hidden'),
+                Query::select(['visible.payload', 'hidden.code']),
+            ]);
+
+            $this->assertSame(1, \count($results));
+            $this->assertSame('open-payload', $results[0]->getAttribute('payload'));
+            $this->assertSame('open-code', $results[0]->getAttribute('code'));
+
+            foreach ($results as $document) {
+                $this->assertNotSame('secret-payload', $document->getAttribute('payload'));
+                $this->assertNotSame('secret-code', $document->getAttribute('code'));
+            }
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testRightJoinDoesNotLeakUnauthorizedJoinDocument(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $cCol = 't8_rjlk_c';
+        $oCol = 't8_rjlk_o';
+        $cols = [$cCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'customerId', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'cust1',
+            'name' => 'Alice',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'cust2',
+            'name' => 'Bob',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            '$id' => 'ord-public',
+            'customerId' => 'cust1',
+            'amount' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            '$id' => 'ord-secret',
+            'customerId' => 'cust1',
+            'amount' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        $authorization->addRole(Role::any()->toString());
+
+        try {
+            $results = $database->find($cCol, [
+                Query::rightJoin($oCol, '$id', 'customerId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+
+            $amounts = [];
+            foreach ($results as $document) {
+                $this->assertNotSame('ord-secret', $document->getId());
+                $amount = $document->getAttribute('amount');
+                if (\is_numeric($amount)) {
+                    $amount = (int) $amount;
+                    $amounts[] = $amount;
+                    $this->assertNotSame(999, $amount);
+                }
+            }
+            $this->assertContains(10, $amounts);
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testFullOuterJoinDoesNotLeakUnauthorizedJoinDocument(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $cCol = 't8_folk_c';
+        $oCol = 't8_folk_o';
+        $cols = [$cCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($cCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($oCol, Attribute::string(key: 'customerId', required: true));
+        $database->createAttribute($oCol, Attribute::integer(key: 'amount', required: true));
+
+        $database->createDocument($cCol, new Document([
+            '$id' => 'cust1',
+            'name' => 'Alice',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'cust2',
+            'name' => 'Bob',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            '$id' => 'ord-public',
+            'customerId' => 'cust1',
+            'amount' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($oCol, new Document([
+            '$id' => 'ord-secret',
+            'customerId' => 'cust1',
+            'amount' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        $authorization->addRole(Role::any()->toString());
+
+        try {
+            $results = $database->find($cCol, [
+                Query::fullOuterJoin($oCol, '$id', 'customerId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+
+            $amounts = [];
+            foreach ($results as $document) {
+                $this->assertNotSame('ord-secret', $document->getId());
+                $amount = $document->getAttribute('amount');
+                if (\is_numeric($amount)) {
+                    $amount = (int) $amount;
+                    $amounts[] = $amount;
+                    $this->assertNotSame(999, $amount);
+                }
+            }
+            $this->assertContains(10, $amounts);
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testRightJoinUnmatchedRowSurvivesSharedTables(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        if (! $database->getAdapter()->supports(Capability::Schemas)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $sharedTables = $database->getSharedTables();
+        $namespace = $database->getNamespace();
+        $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
+
+        $sharedTablesDb = 'sharedTablesRj_'.static::getTestToken();
+        $pCol = 't8_rjst_p';
+        $rCol = 't8_rjst_r';
+
+        try {
+            if ($database->exists($sharedTablesDb)) {
+                $database->setDatabase($sharedTablesDb)->delete();
+            }
+
+            $database
+                ->setDatabase($sharedTablesDb)
+                ->setNamespace('')
+                ->setSharedTables(true)
+                ->setTenant(null)
+                ->create();
+
+            $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+            $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+            $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+            $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+            $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+            $database->setTenant(1);
+            $database->createDocument($pCol, new Document([
+                '$id' => 'p1',
+                'name' => 'Product p1',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($rCol, new Document([
+                '$id' => 'r-match',
+                'prod_uid' => 'p1',
+                'score' => 5,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($rCol, new Document([
+                '$id' => 'r-unmatched',
+                'prod_uid' => 'missing',
+                'score' => 9,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+
+            $database->setTenant(2);
+            $database->createDocument($rCol, new Document([
+                '$id' => 'r-other-tenant',
+                'prod_uid' => 'missing',
+                'score' => 77,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($rCol, new Document([
+                '$id' => 'r-other-match',
+                'prod_uid' => 'p1',
+                'score' => 88,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+
+            $database->setTenant(1);
+            $results = $database->find($pCol, [
+                Query::rightJoin($rCol, '$id', 'prod_uid', '=', 'rev'),
+                Query::select(['name', 'rev.score']),
+            ]);
+
+            $this->assertSame(2, \count($results));
+
+            $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+            \sort($ids);
+            $this->assertSame(['', 'p1'], $ids);
+
+            $scores = [];
+            $unmatched = null;
+            foreach ($results as $document) {
+                $this->assertNotSame('r-other-tenant', $document->getId());
+                $this->assertNotSame('r-other-match', $document->getId());
+                $score = $document->getAttribute('score');
+                if (\is_numeric($score)) {
+                    $score = (int) $score;
+                    $scores[] = $score;
+                    $this->assertNotSame(77, $score);
+                    $this->assertNotSame(88, $score);
+                }
+                if ($document->getId() === '') {
+                    $unmatched = $document;
+                }
+            }
+
+            $this->assertNotNull($unmatched);
+            $this->assertTrue($unmatched->getAttribute('name') === null || $unmatched->getAttribute('name') === '');
+            \sort($scores);
+            $this->assertSame([5, 9], $scores);
+        } finally {
+            $database->setTenant(null)->setSharedTables(false);
+            if ($database->exists($sharedTablesDb)) {
+                $database->delete($sharedTablesDb);
+            }
+            $database
+                ->setSharedTables($sharedTables)
+                ->setTenant($tenant)
+                ->setNamespace($namespace)
+                ->setDatabase($schema);
+        }
+    }
+
+    public function testGetDocumentInnerJoinMatched(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_ijm_p';
+        $rCol = 'gd_ijm_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p1', [
+            Query::join($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $score = $document->getAttribute('score');
+        $this->assertIsNumeric($score);
+        $this->assertSame(5, (int) $score);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentLeftJoinUnmatchedNullish(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_ljun_p';
+        $rCol = 'gd_ljun_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p2', [
+            Query::leftJoin($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $score = $document->getAttribute('score');
+        $this->assertTrue($score === null || $score === '');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentInnerJoinUnmatchedEmpty(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_ijue_p';
+        $rCol = 'gd_ijue_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p2', [
+            Query::join($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(true, $document->isEmpty());
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentRightJoinUnmatchedEmpty(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_rjue_p';
+        $rCol = 'gd_rjue_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p2', [
+            Query::rightJoin($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(true, $document->isEmpty());
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentOneToManyReturnsFirstRow(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_otm_p';
+        $rCol = 'gd_otm_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 3,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p1', [
+            Query::join($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $score = $document->getAttribute('score');
+        $this->assertIsNumeric($score);
+        $this->assertContains((int) $score, [5, 3]);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentSelectPlusJoin(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_spj_p';
+        $rCol = 'gd_spj_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p1', [
+            Query::join($rCol, '$id', 'prod_uid', '=', 'rev'),
+            Query::select(['name', 'rev.score']),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $this->assertSame('Product p1', $document->getAttribute('name'));
+        $score = $document->getAttribute('score');
+        $this->assertIsNumeric($score);
+        $this->assertSame(5, (int) $score);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentRejectsCount(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_rc_p';
+        $rCol = 'gd_rc_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $this->expectException(QueryException::class);
+        try {
+            $database->getDocument($pCol, 'p1', [
+                Query::join($rCol, '$id', 'prod_uid'),
+                Query::count('*', 'cnt'),
+            ]);
+        } finally {
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testGetDocumentRejectsNaturalJoin(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_rnj_p';
+        $rCol = 'gd_rnj_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        try {
+            $database->getDocument($pCol, 'p1', [
+                Query::naturalJoin($rCol),
+            ]);
+            $this->fail('Expected QueryException for natural join');
+        } catch (QueryException $exception) {
+            $this->assertStringContainsString('Natural joins are not supported', $exception->getMessage());
+        } finally {
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testGetDocumentSkipsCacheWhenJoinsPresent(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_sc_p';
+        $rCol = 'gd_sc_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $database->getDocument($pCol, 'p1');
+        $document = $database->getDocument($pCol, 'p1', [
+            Query::leftJoin($rCol, '$id', 'prod_uid', '=', 'rev'),
+            Query::select(['rev.score']),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $this->assertSame('p1', $document->getId());
+        $score = $document->getAttribute('score');
+        $this->assertIsNumeric($score);
+        $this->assertSame(5, (int) $score);
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentJoinKeepsMainDocumentId(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_jmid_p';
+        $rCol = 'gd_jmid_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            '$id' => 'r1',
+            'prod_uid' => 'p1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $inner = $database->getDocument($pCol, 'p1', [
+            Query::join($rCol, '$id', 'prod_uid'),
+        ]);
+        $this->assertSame(false, $inner->isEmpty());
+        $this->assertSame('p1', $inner->getId());
+
+        $left = $database->getDocument($pCol, 'p1', [
+            Query::leftJoin($rCol, '$id', 'prod_uid'),
+        ]);
+        $this->assertSame(false, $left->isEmpty());
+        $this->assertSame('p1', $left->getId());
+
+        $unmatched = $database->getDocument($pCol, 'p2', [
+            Query::leftJoin($rCol, '$id', 'prod_uid'),
+        ]);
+        $this->assertSame(false, $unmatched->isEmpty());
+        $this->assertSame('p2', $unmatched->getId());
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentFullOuterJoinExistingIdBehavesLikeLeft(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_foj_p';
+        $rCol = 'gd_foj_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $document = $database->getDocument($pCol, 'p2', [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+        ]);
+
+        $this->assertSame(false, $document->isEmpty());
+        $this->assertSame('p2', $document->getId());
+        $score = $document->getAttribute('score');
+        $this->assertTrue($score === null || $score === '');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentFullOuterJoinUnauthorizedJoinStillReturnsMain(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 'gd_fojua_p';
+        $rCol = 'gd_fojua_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            '$id' => 'r-secret',
+            'prod_uid' => 'p1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        $authorization->addRole(Role::any()->toString());
+
+        try {
+            $document = $database->getDocument($pCol, 'p1', [
+                Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            ]);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertSame('p1', $document->getId());
+            $this->assertNotSame('r-secret', $document->getId());
+            $score = $document->getAttribute('score');
+            if (\is_numeric($score)) {
+                $score = (int) $score;
+                $this->assertNotSame(999, $score);
+            }
+
+            $left = $database->getDocument($pCol, 'p1', [
+                Query::leftJoin($rCol, '$id', 'prod_uid'),
+            ]);
+            $this->assertSame(false, $left->isEmpty());
+            $this->assertSame('p1', $left->getId());
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+            $this->cleanupAggCollections($database, $cols);
+        }
+    }
+
+    public function testFullOuterJoinLimitAppliesToOuterQuery(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_folim_p';
+        $rCol = 't8_folim_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p1',
+            'name' => 'Product p1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($pCol, new Document([
+            '$id' => 'p2',
+            'name' => 'Product p2',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing1',
+            'score' => 8,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($rCol, new Document([
+            'prod_uid' => 'missing2',
+            'score' => 9,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $results = $database->find($pCol, [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            Query::limit(2),
+        ]);
+
+        $this->assertSame(2, \count($results));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testFullOuterJoinOffsetAppliesToOuterQuery(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $pCol = 't8_fooff_p';
+        $rCol = 't8_fooff_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        foreach (['p1', 'p2', 'p3', 'p4'] as $id) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $id,
+                'name' => 'Product '.$id,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        $queries = [
+            Query::fullOuterJoin($rCol, '$id', 'prod_uid'),
+            Query::orderAsc('name'),
+        ];
+
+        $full = $database->find($pCol, $queries);
+        $sliced = $database->find($pCol, [
+            ...$queries,
+            Query::limit(2),
+            Query::offset(1),
+        ]);
+
+        $identity = static function (Document $document): string {
+            $name = $document->getAttribute('name');
+            $score = $document->getAttribute('score');
+
+            return $document->getId().':'.(\is_scalar($name) ? (string) $name : '').':'.(\is_scalar($score) ? (string) $score : '');
+        };
+
+        $this->assertSame(2, \count($sliced));
+        $this->assertSame(
+            \array_slice(\array_map($identity, $full), 1, 2),
+            \array_map($identity, $sliced)
+        );
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinCollectionAclRejectsUnauthorizedJoinedCollection(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_nocr_m';
+        $jCol = 'jp_nocr_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $mCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $jCol, permissions: [Permission::create(Role::any())], documentSecurity: false));
+        $database->createAttribute($jCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($jCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $joins = [
+                Query::join($jCol, '$id', 'mainId'),
+                Query::leftJoin($jCol, '$id', 'mainId'),
+                Query::rightJoin($jCol, '$id', 'mainId'),
+                Query::fullOuterJoin($jCol, '$id', 'mainId'),
+                Query::crossJoin($jCol),
+            ];
+
+            foreach ($joins as $join) {
+                try {
+                    $results = $database->find($mCol, [$join]);
+                    foreach ($results as $document) {
+                        $this->assertJoinAttributesAbsent($document);
+                        $this->assertSecretJoinHidden($document, 'j-secret', 999);
+                    }
+                } catch (AuthorizationException|QueryException $exception) {
+                    $this->assertNotSame('', $exception->getMessage());
+                }
+            }
+
+            try {
+                $document = $database->getDocument($mCol, 'm1', [
+                    Query::join($jCol, '$id', 'mainId'),
+                ]);
+                if (! $document->isEmpty()) {
+                    $this->assertJoinAttributesAbsent($document);
+                    $this->assertSecretJoinHidden($document, 'j-secret', 999);
+                }
+            } catch (AuthorizationException|QueryException $exception) {
+                $this->assertNotSame('', $exception->getMessage());
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinCollectionAclAllowsWhenDocumentSecurityOff(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_dsoff_m';
+        $jCol = 'jp_dsoff_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $mCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $jCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($jCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($jCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j1',
+            'mainId' => 'm1',
+            'score' => 5,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertContains(5, $this->numericScores($results));
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinCollectionAclAllowsWhenDocumentSecurityOffOnPhysicalIds(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'database_1_collection_1';
+        $jCol = 'database_1_collection_2';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $mCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $jCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($jCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($jCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId', '=', 'rev'),
+                Query::select(['name', 'rev.score']),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $this->assertContains(999, $this->aliasedScores($results));
+
+            $rewritten = Query::leftJoin('jp_dsoff_public', '$id', 'mainId', '=', 'rev');
+            $rewritten->setAttribute($jCol);
+            $rewrittenResults = $database->find($mCol, [
+                $rewritten,
+                Query::select(['name', 'rev.score']),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($rewrittenResults));
+            $this->assertContains(999, $this->aliasedScores($rewrittenResults));
+
+            $document = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($jCol, '$id', 'mainId', '=', 'rev'),
+                Query::select(['name', 'rev.score']),
+            ]);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertContains(999, $this->aliasedScores([$document]));
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testInnerJoinDoesNotLeakUnauthorizedJoinDocument(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_ij_m';
+        $jCol = 'jp_ij_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            foreach ($results as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+            $this->assertContains(10, $this->numericScores($results));
+            $this->assertSame(false, \in_array(999, $this->numericScores($results), true));
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testLeftJoinUnauthorizedJoinAttributesAreNullish(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_lj_m';
+        $jCol = 'jp_lj_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Alice',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'Bob',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(2, \count($results));
+            $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+            $this->assertContains('m1', $ids);
+            $this->assertContains('m2', $ids);
+
+            foreach ($results as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+                $this->assertNullishScore($document);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testRightJoinDoesNotLeakUnauthorizedMainOrJoin(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_rj_m';
+        $jCol = 'jp_rj_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm-public',
+            'name' => 'Public Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm-secret',
+            'name' => 'Secret Main',
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm-public',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm-secret',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-unmatched',
+            'mainId' => 'missing',
+            'score' => 7,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-unmatched-secret',
+            'mainId' => 'missing-secret',
+            'score' => 888,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::rightJoin($jCol, '$id', 'mainId'),
+            ]);
+
+            $this->assertGreaterThanOrEqual(1, \count($results));
+            $scores = $this->numericScores($results);
+            $this->assertContains(10, $scores);
+            $this->assertSame(false, \in_array(999, $scores, true));
+            $this->assertSame(false, \in_array(888, $scores, true));
+
+            foreach ($results as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+                $this->assertNotSame('m-secret', $document->getId());
+                $this->assertNotSame('j-unmatched-secret', $document->getId());
+                $name = $document->getAttribute('name');
+                $this->assertNotSame('Secret Main', $name);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testFullOuterJoinFindPermissionMatrix(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_fo_m';
+        $jCol = 'jp_fo_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Matched',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'Unmatched Left',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm-secret',
+            'name' => 'Secret Main',
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-unmatched',
+            'mainId' => 'missing',
+            'score' => 7,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-unmatched-secret',
+            'mainId' => 'missing-secret',
+            'score' => 888,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::fullOuterJoin($jCol, '$id', 'mainId'),
+            ]);
+
+            $ids = \array_map(static fn (Document $document): string => $document->getId(), $results);
+            $this->assertContains('m1', $ids);
+            $this->assertContains('m2', $ids);
+            $this->assertSame(false, \in_array('m-secret', $ids, true));
+            $this->assertSame(false, \in_array('j-secret', $ids, true));
+            $this->assertSame(false, \in_array('j-unmatched-secret', $ids, true));
+
+            $scores = $this->numericScores($results);
+            $this->assertContains(10, $scores);
+            $this->assertContains(7, $scores);
+            $this->assertSame(false, \in_array(999, $scores, true));
+            $this->assertSame(false, \in_array(888, $scores, true));
+
+            $unmatchedLeft = null;
+            $unmatchedRight = null;
+            foreach ($results as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+                $this->assertNotSame('Secret Main', $document->getAttribute('name'));
+                if ($document->getId() === 'm2') {
+                    $unmatchedLeft = $document;
+                }
+                if ($document->getId() === '') {
+                    $score = $document->getAttribute('score');
+                    if (\is_numeric($score) && (int) $score === 7) {
+                        $unmatchedRight = $document;
+                    }
+                }
+            }
+
+            $this->assertNotNull($unmatchedLeft);
+            $this->assertNullishScore($unmatchedLeft);
+            $this->assertNotNull($unmatchedRight);
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testCrossJoinDoesNotLeakUnauthorizedJoinDocuments(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_xj_m';
+        $jCol = 'jp_xj_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'A',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'B',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::crossJoin($jCol),
+            ]);
+
+            $this->assertSame(2, \count($results));
+            foreach ($results as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+            $this->assertSame([10, 10], $this->numericScores($results));
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentJoinPermissionMatrix(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_gd_m';
+        $jCol = 'jp_gd_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Secret Match',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'Public Match',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm3',
+            'name' => 'Unmatched',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm2',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $innerSecret = $database->getDocument($mCol, 'm1', [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(true, $innerSecret->isEmpty());
+
+            $innerPublic = $database->getDocument($mCol, 'm2', [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $innerPublic->isEmpty());
+            $this->assertSame('m2', $innerPublic->getId());
+            $this->assertSecretJoinHidden($innerPublic, 'j-secret', 999);
+            $publicScore = $innerPublic->getAttribute('score');
+            $this->assertTrue(\is_numeric($publicScore));
+            $this->assertSame(10, (int) $publicScore);
+
+            $leftSecret = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $leftSecret->isEmpty());
+            $this->assertSame('m1', $leftSecret->getId());
+            $this->assertNotSame('j-secret', $leftSecret->getId());
+            $this->assertSecretJoinHidden($leftSecret, 'j-secret', 999);
+            $this->assertNullishScore($leftSecret);
+
+            $leftPublic = $database->getDocument($mCol, 'm2', [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $leftPublic->isEmpty());
+            $this->assertSame('m2', $leftPublic->getId());
+
+            $rightSecret = $database->getDocument($mCol, 'm1', [
+                Query::rightJoin($jCol, '$id', 'mainId'),
+            ]);
+            if (! $rightSecret->isEmpty()) {
+                $this->assertSame('m1', $rightSecret->getId());
+                $this->assertSecretJoinHidden($rightSecret, 'j-secret', 999);
+            }
+
+            $rightPublic = $database->getDocument($mCol, 'm2', [
+                Query::rightJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $rightPublic->isEmpty());
+            $this->assertSame('m2', $rightPublic->getId());
+            $this->assertSecretJoinHidden($rightPublic, 'j-secret', 999);
+
+            $fojSecret = $database->getDocument($mCol, 'm1', [
+                Query::fullOuterJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $fojSecret->isEmpty());
+            $this->assertSame('m1', $fojSecret->getId());
+            $this->assertNotSame('j-secret', $fojSecret->getId());
+            $this->assertSecretJoinHidden($fojSecret, 'j-secret', 999);
+            $this->assertNullishScore($fojSecret);
+
+            $fojPublic = $database->getDocument($mCol, 'm2', [
+                Query::fullOuterJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $fojPublic->isEmpty());
+            $this->assertSame('m2', $fojPublic->getId());
+            $this->assertSecretJoinHidden($fojPublic, 'j-secret', 999);
+
+            $fojUnmatched = $database->getDocument($mCol, 'm3', [
+                Query::fullOuterJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $fojUnmatched->isEmpty());
+            $this->assertSame('m3', $fojUnmatched->getId());
+            $this->assertSecretJoinHidden($fojUnmatched, 'j-secret', 999);
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinSelectDoesNotReturnSecretScore(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_sel_m';
+        $jCol = 'jp_sel_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $finds = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId', '=', 'rev'),
+                Query::select(['name', 'rev.score']),
+            ]);
+            foreach ($finds as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+            $this->assertContains(10, $this->numericScores($finds));
+            $this->assertSame(false, \in_array(999, $this->numericScores($finds), true));
+
+            $document = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($jCol, '$id', 'mainId', '=', 'rev'),
+                Query::select(['rev.score']),
+            ]);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertSame('m1', $document->getId());
+            $this->assertSecretJoinHidden($document, 'j-secret', 999);
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinDoesNotLeakOtherTenantRows(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $sharedTables = $database->getSharedTables();
+        $supportsSchemas = $database->getAdapter()->supports(Capability::Schemas);
+        if (! $sharedTables && ! $supportsSchemas) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $namespace = $database->getNamespace();
+        $schema = $database->getDatabase();
+        $tenant = $database->getTenant();
+        $createdDatabase = false;
+        $sharedTablesDb = 'sharedTablesJp_'.static::getTestToken();
+        $mCol = 'jp_tn_m';
+        $jCol = 'jp_tn_j';
+        $cols = [$mCol, $jCol];
+
+        try {
+            if ($supportsSchemas) {
+                if ($database->exists($sharedTablesDb)) {
+                    $database->setDatabase($sharedTablesDb)->delete();
+                }
+
+                $database
+                    ->setDatabase($sharedTablesDb)
+                    ->setNamespace('')
+                    ->setSharedTables(true)
+                    ->setTenant(null)
+                    ->create();
+                $createdDatabase = true;
+            } else {
+                $database->setTenant(null);
+            }
+
+            $this->cleanupAggCollections($database, $cols);
+            $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+            $database->setTenant(1);
+            $database->createDocument($mCol, new Document([
+                '$id' => 'm1',
+                'name' => 'Tenant One',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($mCol, new Document([
+                '$id' => 'm2',
+                'name' => 'Unmatched Left',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($jCol, new Document([
+                '$id' => 'j-match',
+                'mainId' => 'm1',
+                'score' => 5,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+
+            $database->setTenant(2);
+            $database->createDocument($jCol, new Document([
+                '$id' => 'j-other-match',
+                'mainId' => 'm1',
+                'score' => 88,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+            $database->createDocument($jCol, new Document([
+                '$id' => 'j-other-unmatched',
+                'mainId' => 'missing',
+                'score' => 77,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+
+            $database->setTenant(1);
+            $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+                foreach ([
+                    [Query::join($jCol, '$id', 'mainId')],
+                    [Query::leftJoin($jCol, '$id', 'mainId')],
+                    [Query::fullOuterJoin($jCol, '$id', 'mainId')],
+                ] as $queries) {
+                    $results = $database->find($mCol, $queries);
+                    $this->assertGreaterThanOrEqual(1, \count($results));
+                    $scores = $this->numericScores($results);
+                    $this->assertSame(false, \in_array(88, $scores, true));
+                    $this->assertSame(false, \in_array(77, $scores, true));
+                    foreach ($results as $document) {
+                        $this->assertNotSame('j-other-match', $document->getId());
+                        $this->assertNotSame('j-other-unmatched', $document->getId());
+                        $this->assertSecretJoinHidden($document, 'j-other-match', 88);
+                    }
+                }
+            });
+        } finally {
+            if ($createdDatabase) {
+                $database->setTenant(null)->setSharedTables(false);
+                if ($database->exists($sharedTablesDb)) {
+                    $database->delete($sharedTablesDb);
+                }
+                $database
+                    ->setSharedTables($sharedTables)
+                    ->setTenant($tenant)
+                    ->setNamespace($namespace)
+                    ->setDatabase($schema);
+            } else {
+                $database->setTenant(null);
+                $this->cleanupAggCollections($database, $cols);
+                $database->setTenant($tenant);
+            }
+        }
+    }
+
+    public function testJoinSecretRowOnlyVisibleToMatchingRole(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_rl_m';
+        $jCol = 'jp_rl_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $mCol, permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::read(Role::user('jp-acl')),
+            Permission::read(Role::guests()),
+        ]));
+        $database->createAttribute($mCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $jCol, permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::read(Role::user('jp-acl')),
+            Permission::read(Role::guests()),
+        ]));
+        $database->createAttribute($jCol, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($jCol, Attribute::integer(key: 'score', required: true));
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::read(Role::user('jp-acl')),
+                Permission::read(Role::guests()),
+            ],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-any',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-guest',
+            'mainId' => 'm1',
+            'score' => 20,
+            '$permissions' => [Permission::read(Role::guests())],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $scores = $this->numericScores($results);
+            $this->assertContains(10, $scores);
+            $this->assertSame(false, \in_array(999, $scores, true));
+            $this->assertSame(false, \in_array(20, $scores, true));
+            foreach ($results as $document) {
+                $this->assertNotSame('j-secret', $document->getId());
+            }
+        });
+
+        $this->withAuthorizationRoles($database, [Role::user('jp-acl')->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $scores = $this->numericScores($results);
+            $this->assertContains(999, $scores);
+            $this->assertSame(false, \in_array(10, $scores, true));
+            $this->assertSame(false, \in_array(20, $scores, true));
+        });
+
+        $this->withAuthorizationRoles($database, [Role::guests()->toString()], function () use ($database, $mCol, $jCol): void {
+            $results = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $scores = $this->numericScores($results);
+            $this->assertContains(20, $scores);
+            $this->assertSame(false, \in_array(999, $scores, true));
+            $this->assertSame(false, \in_array(10, $scores, true));
+            foreach ($results as $document) {
+                $this->assertNotSame('j-secret', $document->getId());
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinSkipAuthDoesNotSkipJoinSideAcl(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_sa_m';
+        $jCol = 'jp_sa_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $withoutJoin = $database->find($mCol);
+            $this->assertSame(1, \count($withoutJoin));
+            $this->assertSame('m1', $withoutJoin[0]->getId());
+
+            $inner = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertContains(10, $this->numericScores($inner));
+            $this->assertSame(false, \in_array(999, $this->numericScores($inner), true));
+            foreach ($inner as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+
+            $left = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertGreaterThanOrEqual(1, \count($left));
+            foreach ($left as $document) {
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+
+            $document = $database->getDocument($mCol, 'm1', [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            if (! $document->isEmpty()) {
+                $this->assertSame('m1', $document->getId());
+                $this->assertSecretJoinHidden($document, 'j-secret', 999);
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinFilterOrderHavingOracleDoesNotRevealSecret(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_foh_m';
+        $jCol = 'jp_foh_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $join = Query::join($jCol, '$id', 'mainId', '=', 'rev');
+            $baseline = $database->find($mCol, [$join]);
+            $this->assertSame(1, \count($baseline));
+            $this->assertContains(10, $this->numericScores($baseline));
+            $this->assertSecretJoinPayloadHidden($baseline, 'j-secret', 999);
+
+            $filtered = $database->find($mCol, [
+                $join,
+                Query::equal('rev.score', [999]),
+            ]);
+            $this->assertLessThanOrEqual(\count($baseline), \count($filtered));
+            $this->assertSecretJoinPayloadHidden($filtered, 'j-secret', 999);
+
+            $ordered = $database->find($mCol, [
+                $join,
+                Query::orderDesc('rev.score'),
+            ]);
+            $this->assertSame(\count($baseline), \count($ordered));
+            $this->assertSecretJoinPayloadHidden($ordered, 'j-secret', 999);
+
+            if (! $database->getAdapter()->supports(Capability::Aggregations)) {
+                return;
+            }
+
+            $aggregated = $database->find($mCol, [
+                $join,
+                Query::max('rev.score', 'max_score'),
+                Query::groupBy(['name']),
+                Query::having([Query::greaterThanEqual('max_score', 999)]),
+            ]);
+            $this->assertLessThanOrEqual(\count($baseline), \count($aggregated));
+            $this->assertSecretJoinPayloadHidden($aggregated, 'j-secret', 999);
+
+            $maxOnly = $database->find($mCol, [
+                $join,
+                Query::max('rev.score', 'max_score'),
+                Query::groupBy(['name']),
+            ]);
+            $this->assertSecretJoinPayloadHidden($maxOnly, 'j-secret', 999);
+            foreach ($maxOnly as $document) {
+                $maxScore = $document->getAttribute('max_score');
+                if (\is_numeric($maxScore)) {
+                    $this->assertNotSame(999, (int) $maxScore);
+                }
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinExactCountHidesSecretSiblingOnSameDocument(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_exc_m';
+        $jCol = 'jp_exc_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Matched',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm2',
+            'name' => 'Unmatched',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('jp-acl'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $inner = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(1, \count($inner));
+            $this->assertSame('m1', $inner[0]->getId());
+            $this->assertContains(10, $this->numericScores($inner));
+            $this->assertSecretJoinPayloadHidden($inner, 'j-secret', 999);
+
+            $publicMains = $database->find($mCol);
+            $this->assertSame(2, \count($publicMains));
+
+            $left = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(\count($publicMains), \count($left));
+            $this->assertSecretJoinPayloadHidden($left, 'j-secret', 999);
+            foreach ($left as $document) {
+                if ($document->getId() !== 'm1') {
+                    $this->assertNullishScore($document);
+                }
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinMixedDocumentSecurityHidesSecretOnFindAndGetDocument(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_mds_m';
+        $jCol = 'jp_mds_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createMixedJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-public',
+            'mainId' => 'm1',
+            'score' => 10,
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $inner = $database->find($mCol, [
+                Query::join($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(1, \count($inner));
+            $this->assertSame('m1', $inner[0]->getId());
+            $this->assertContains(10, $this->numericScores($inner));
+            $this->assertSecretJoinPayloadHidden($inner, 'j-secret', 999, 'user:other');
+
+            $left = $database->find($mCol, [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(1, \count($left));
+            $this->assertSame('m1', $left[0]->getId());
+            $this->assertSecretJoinPayloadHidden($left, 'j-secret', 999, 'user:other');
+
+            $document = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertSame('m1', $document->getId());
+            $this->assertSecretJoinHidden($document, 'j-secret', 999, 'user:other');
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testJoinThreeTableDeniesUnauthorizedCollection(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $aCol = 'jp_3d_a';
+        $bCol = 'jp_3d_b';
+        $cCol = 'jp_3d_c';
+        $cols = [$aCol, $bCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $aCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($aCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $bCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($bCol, Attribute::string(key: 'aId', required: true));
+
+        $database->createCollection(new Collection(id: $cCol, permissions: [Permission::create(Role::any())], documentSecurity: false));
+        $database->createAttribute($cCol, Attribute::string(key: 'bId', required: true));
+        $database->createAttribute($cCol, Attribute::string(key: 'secret', size: 100, required: true));
+
+        $database->createDocument($aCol, new Document([
+            '$id' => 'a1',
+            'name' => 'Alpha',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($bCol, new Document([
+            '$id' => 'b1',
+            'aId' => 'a1',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($cCol, new Document([
+            '$id' => 'c-secret',
+            'bId' => 'b1',
+            'secret' => 'c-secret-token',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $aCol, $bCol, $cCol): void {
+            try {
+                $results = $database->find($aCol, [
+                    Query::join($bCol, '$id', 'aId', '=', 'b'),
+                    Query::join($cCol, 'b.$id', 'bId', '=', 'c'),
+                ]);
+                foreach ($results as $document) {
+                    $encoded = \json_encode($document);
+                    $this->assertNotFalse($encoded);
+                    $this->assertSame(false, \str_contains($encoded, 'c-secret-token'));
+                    $this->assertSame(false, \str_contains($encoded, 'c-secret'));
+                    $this->assertNotSame('c-secret-token', $document->getAttribute('secret'));
+                }
+                $this->fail('Join A→B→C must reject unauthorized collection C');
+            } catch (AuthorizationException $exception) {
+                $this->assertSame(true, \str_contains($exception->getMessage(), 'Unauthorized access to joined collection'));
+                $this->assertSame(true, \str_contains($exception->getMessage(), $cCol));
+            }
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    public function testGetDocumentJoinSkipAuthDoesNotRevealSecret(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $mCol = 'jp_gds_m';
+        $jCol = 'jp_gds_j';
+        $cols = [$mCol, $jCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $this->createMixedJoinPermissionCollections($database, $mCol, $jCol);
+
+        $database->createDocument($mCol, new Document([
+            '$id' => 'm1',
+            'name' => 'Main',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $database->createDocument($jCol, new Document([
+            '$id' => 'j-secret',
+            'mainId' => 'm1',
+            'score' => 999,
+            '$permissions' => [Permission::read(Role::user('other'))],
+        ]));
+
+        $this->withAuthorizationRoles($database, [Role::any()->toString()], function () use ($database, $mCol, $jCol): void {
+            $document = $database->getDocument($mCol, 'm1', [
+                Query::leftJoin($jCol, '$id', 'mainId'),
+            ]);
+            $this->assertSame(false, $document->isEmpty());
+            $this->assertSame('m1', $document->getId());
+            $this->assertSecretJoinHidden($document, 'j-secret', 999, 'user:other');
+            $this->assertNullishScore($document);
+        });
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+
+    /**
+     * @param list<string> $roles
+     * @param callable(): void $callback
+     */
+    private function withAuthorizationRoles(Database $database, array $roles, callable $callback): void
+    {
+        $authorization = $database->getAuthorization();
+        $previousRoles = $authorization->getRoles();
+        $authorization->cleanRoles();
+        foreach ($roles as $role) {
+            $authorization->addRole($role);
+        }
+
+        try {
+            $callback();
+        } finally {
+            $authorization->cleanRoles();
+            foreach ($previousRoles as $role) {
+                $authorization->addRole($role);
+            }
+        }
+    }
+
+    private function createJoinPermissionCollections(Database $database, string $main, string $joined): void
+    {
+        $database->createCollection(new Collection(id: $main, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($main, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $joined, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($joined, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($joined, Attribute::integer(key: 'score', required: true));
+    }
+
+    private function createMixedJoinPermissionCollections(Database $database, string $main, string $joined): void
+    {
+        $database->createCollection(new Collection(id: $main, permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: false));
+        $database->createAttribute($main, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $joined, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($joined, Attribute::string(key: 'mainId', required: true));
+        $database->createAttribute($joined, Attribute::integer(key: 'score', required: true));
+    }
+
+    /**
+     * @param array<Document> $documents
+     */
+    private function assertSecretJoinPayloadHidden(array $documents, string $secretId, int $secretScore, string $forbiddenRole = 'user:jp-acl'): void
+    {
+        $payload = [];
+        foreach ($documents as $document) {
+            $this->assertSecretJoinHidden($document, $secretId, $secretScore, $forbiddenRole);
+            $payload[] = $document->getArrayCopy();
+        }
+
+        $this->assertEncodedJoinSecretHidden(\json_encode($payload), $secretId, $secretScore, $forbiddenRole);
+    }
+
+    private function assertSecretJoinHidden(Document $document, string $secretId, int $secretScore, string $forbiddenRole = 'user:jp-acl'): void
+    {
+        $this->assertNotSame($secretId, $document->getId());
+
+        $score = $document->getAttribute('score');
+        if (\is_numeric($score)) {
+            $this->assertNotSame($secretScore, (int) $score);
+        }
+
+        $amount = $document->getAttribute('amount');
+        if (\is_numeric($amount)) {
+            $this->assertNotSame($secretScore, (int) $amount);
+        }
+
+        foreach ($document->getPermissions() as $permission) {
+            $this->assertSame(false, \str_contains($permission, $secretId));
+            $this->assertSame(false, \str_contains($permission, $forbiddenRole));
+        }
+
+        $this->assertEncodedJoinSecretHidden(\json_encode($document), $secretId, $secretScore, $forbiddenRole);
+    }
+
+    private function assertEncodedJoinSecretHidden(string|false $encoded, string $secretId, int $secretScore, string $forbiddenRole): void
+    {
+        $this->assertNotFalse($encoded);
+        $this->assertSame(false, \str_contains($encoded, $secretId));
+        $this->assertSame(false, \str_contains($encoded, $forbiddenRole));
+        $this->assertSame(false, $this->encodedJsonContainsScalar($encoded, $secretScore));
+    }
+
+    private function encodedJsonContainsScalar(string $encoded, int $needle): bool
+    {
+        $decoded = \json_decode($encoded, true);
+        if (! \is_array($decoded)) {
+            return false;
+        }
+
+        return $this->jsonContainsScalar($decoded, $needle);
+    }
+
+    private function jsonContainsScalar(mixed $value, int $needle, string|int|null $key = null): bool
+    {
+        if (\is_int($value) || \is_float($value) || (\is_string($value) && \is_numeric($value))) {
+            if ($this->isIgnoredJoinSecretKey($key)) {
+                return false;
+            }
+
+            return (int) $value === $needle;
+        }
+
+        if (! \is_array($value)) {
+            return false;
+        }
+
+        foreach ($value as $childKey => $child) {
+            if ($this->jsonContainsScalar($child, $needle, $childKey)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function isIgnoredJoinSecretKey(string|int|null $key): bool
+    {
+        return \in_array($key, [
+            Document::SEQUENCE,
+            Document::CREATED_AT,
+            Document::UPDATED_AT,
+            Document::TENANT,
+            Document::VERSION,
+            Document::COLLECTION,
+            Document::DISTANCE,
+            Document::DELETED_AT,
+            Document::INTERNAL_ID,
+            Document::SKIP_PERMISSIONS_UPDATE,
+        ], true);
+    }
+
+    private function assertJoinAttributesAbsent(Document $document): void
+    {
+        $score = $document->getAttribute('score');
+        $this->assertTrue($score === null || $score === '');
+        $amount = $document->getAttribute('amount');
+        $this->assertTrue($amount === null || $amount === '');
+    }
+
+    private function assertNullishScore(Document $document): void
+    {
+        $score = $document->getAttribute('score');
+        $this->assertTrue($score === null || $score === '');
+    }
+
+    /**
+     * @param array<Document> $documents
+     * @return list<int>
+     */
+    private function numericScores(array $documents): array
+    {
+        $scores = [];
+        foreach ($documents as $document) {
+            $score = $document->getAttribute('score');
+            if (\is_numeric($score)) {
+                $scores[] = (int) $score;
+            }
+        }
+
+        return $scores;
+    }
+
+    /**
+     * @param array<Document> $documents
+     * @return list<int>
+     */
+    private function aliasedScores(array $documents): array
+    {
+        $scores = [];
+        foreach ($documents as $document) {
+            $score = $document->getAttribute('rev.score') ?? $document->getAttribute('score');
+            if (\is_numeric($score)) {
+                $scores[] = (int) $score;
+            }
+        }
+
+        return $scores;
+    }
+
+    public function testLeftJoinOnFilterKeepsUnmatchedMainRows(): void
+    {
+        $database = static::getDatabase();
+        if (! $database->getAdapter()->supports(Capability::Joins)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $pCol = 'ljon_p';
+        $rCol = 'ljon_r';
+        $cols = [$pCol, $rCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection(new Collection(id: $pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($pCol, Attribute::string(key: 'name', size: 100, required: true));
+
+        $database->createCollection(new Collection(id: $rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]));
+        $database->createAttribute($rCol, Attribute::string(key: 'prod_uid', required: true));
+        $database->createAttribute($rCol, Attribute::integer(key: 'score', required: true));
+
+        foreach (['p1' => 'Alpha', 'p2' => 'Beta', 'p3' => 'Gamma'] as $id => $name) {
+            $database->createDocument($pCol, new Document([
+                '$id' => $id,
+                'name' => $name,
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        }
+
+        foreach ([
+            ['prod_uid' => 'p1', 'score' => 5],
+            ['prod_uid' => 'p2', 'score' => 2],
+        ] as $review) {
+            $database->createDocument($rCol, new Document(array_merge($review, [
+                '$permissions' => [Permission::read(Role::any())],
+            ])));
+        }
+
+        $results = $database->find($pCol, [
+            Query::leftJoin($rCol, 'rev', [
+                Query::on('$id', 'prod_uid'),
+                Query::greaterThanEqual('rev.score', 4),
+            ]),
+            Query::select(['name', 'rev.score']),
+        ]);
+
+        $this->assertCount(3, $results);
+        $mapped = [];
+        foreach ($results as $doc) {
+            $name = $doc->getAttribute('name');
+            $this->assertIsString($name);
+            $mapped[$name] = $doc->getAttribute('rev.score');
+        }
+        $this->assertEquals(5, $mapped['Alpha']);
+        $this->assertTrue($mapped['Beta'] === null || $mapped['Beta'] === '');
+        $this->assertTrue($mapped['Gamma'] === null || $mapped['Gamma'] === '');
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+}
diff --git a/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php b/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
index eb49409dc8..2e6df53bb4 100644
--- a/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
+++ b/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
@@ -3,17 +3,22 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Index as IndexException;
 use Utopia\Database\Exception\Query as QueryException;
-use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\Order;
 
 trait ObjectAttributeTests
 {
@@ -21,41 +26,56 @@ trait ObjectAttributeTests
      * Helper function to create an attribute if adapter supports attributes,
      * otherwise returns true to allow tests to continue
      *
-     * @param Database $database
-     * @param string $collectionId
-     * @param string $attributeId
-     * @param string $type
-     * @param int $size
-     * @param bool $required
-     * @param mixed $default
-     * @return bool
+     * @param  mixed  $default
      */
-    private function createAttribute(Database $database, string $collectionId, string $attributeId, string $type, int $size, bool $required, $default = null): bool
+    private function createAttribute(Database $database, string $collectionId, string $attributeId, ColumnType $type, int $size, bool $required, $default = null): bool
     {
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             return true;
         }
 
-        $result = $database->createAttribute($collectionId, $attributeId, $type, $size, $required, $default);
+        $result = $database->createAttribute($collectionId, new Attribute(key: $attributeId, type: $type, size: $size, required: $required, default: $default));
         $this->assertEquals(true, $result);
+
         return $result;
     }
 
+    /**
+     * @param  array<int|string, mixed>  $data
+     * @param  non-empty-list<int|string>  $path
+     */
+    private function nestedMetaValue(array $data, array $path): mixed
+    {
+        $current = $data;
+        $lastIndex = count($path) - 1;
+        foreach ($path as $index => $key) {
+            $this->assertArrayHasKey($key, $current);
+            if ($index === $lastIndex) {
+                return $current[$key];
+            }
+            $nested = $current[$key];
+            $this->assertIsArray($nested);
+            $current = $nested;
+        }
+
+        return $current;
+    }
+
     public function testObjectAttribute(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
         // Skip test if adapter doesn't support JSONB
-        if (!$database->getAdapter()->getSupportForObject()) {
+        if (! $database->getAdapter()->supports(Capability::Objects)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create object attribute
-        $this->createAttribute($database, $collectionId, 'meta', Database::VAR_OBJECT, 0, false);
+        $this->createAttribute($database, $collectionId, 'meta', ColumnType::Object, 0, false);
 
         // Test 1: Create and read document with object attribute
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -66,20 +86,25 @@ public function testObjectAttribute(): void
                 'skills' => ['react', 'node'],
                 'user' => [
                     'info' => [
-                        'country' => 'IN'
-                    ]
-                ]
-            ]
+                        'country' => 'IN',
+                    ],
+                ],
+            ],
         ]));
 
         $this->assertIsArray($doc1->getAttribute('meta'));
-        $this->assertEquals(25, $doc1->getAttribute('meta')['age']);
-        $this->assertEquals(['react', 'node'], $doc1->getAttribute('meta')['skills']);
-        $this->assertEquals('IN', $doc1->getAttribute('meta')['user']['info']['country']);
+        $meta = $doc1->getArray('meta');
+        $this->assertEquals(25, $meta['age']);
+        $this->assertEquals(['react', 'node'], $meta['skills']);
+        $user = $meta['user'] ?? null;
+        $this->assertIsArray($user);
+        $info = $user['info'] ?? null;
+        $this->assertIsArray($info);
+        $this->assertEquals('IN', $info['country']);
 
         // Test 2: Query::equal with simple key-value pair
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['age' => 25]])
+            Query::equal('meta', [['age' => 25]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
@@ -89,17 +114,17 @@ public function testObjectAttribute(): void
             Query::equal('meta', [[
                 'user' => [
                     'info' => [
-                        'country' => 'IN'
-                    ]
-                ]
-            ]])
+                        'country' => 'IN',
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
 
         // Test 4: Query::contains for array element
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['skills' => 'react']])
+            Query::contains('meta', [['skills' => 'react']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
@@ -113,15 +138,15 @@ public function testObjectAttribute(): void
                 'skills' => ['python', 'java'],
                 'user' => [
                     'info' => [
-                        'country' => 'US'
-                    ]
-                ]
-            ]
+                        'country' => 'US',
+                    ],
+                ],
+            ],
         ]));
 
         // Test 6: Query should return only doc1
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['age' => 25]])
+            Query::equal('meta', [['age' => 25]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
@@ -131,10 +156,10 @@ public function testObjectAttribute(): void
             Query::equal('meta', [[
                 'user' => [
                     'info' => [
-                        'country' => 'US'
-                    ]
-                ]
-            ]])
+                        'country' => 'US',
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc2', $results[0]->getId());
@@ -148,39 +173,44 @@ public function testObjectAttribute(): void
                 'skills' => ['react', 'node', 'typescript'],
                 'user' => [
                     'info' => [
-                        'country' => 'CA'
-                    ]
-                ]
-            ]
+                        'country' => 'CA',
+                    ],
+                ],
+            ],
         ]));
 
-        $this->assertEquals(26, $updatedDoc->getAttribute('meta')['age']);
-        $this->assertEquals(['react', 'node', 'typescript'], $updatedDoc->getAttribute('meta')['skills']);
-        $this->assertEquals('CA', $updatedDoc->getAttribute('meta')['user']['info']['country']);
+        $updatedMeta = $updatedDoc->getArray('meta');
+        $this->assertEquals(26, $updatedMeta['age']);
+        $this->assertEquals(['react', 'node', 'typescript'], $updatedMeta['skills']);
+        $updatedUser = $updatedMeta['user'] ?? null;
+        $this->assertIsArray($updatedUser);
+        $updatedInfo = $updatedUser['info'] ?? null;
+        $this->assertIsArray($updatedInfo);
+        $this->assertEquals('CA', $updatedInfo['country']);
 
         // Test 9: Query updated document
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['age' => 26]])
+            Query::equal('meta', [['age' => 26]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
 
         // Test 10: Query with multiple conditions using contains
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['skills' => 'typescript']])
+            Query::contains('meta', [['skills' => 'typescript']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
 
         // Test 11: Negative test - query that shouldn't match
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['age' => 99]])
+            Query::equal('meta', [['age' => 99]]),
         ]);
         $this->assertCount(0, $results);
 
         // Test 11d: notEqual on scalar inside object should exclude doc1
         $results = $database->find($collectionId, [
-            Query::notEqual('meta', ['age' => 26])
+            Query::notEqual('meta', ['age' => 26]),
         ]);
         // Should return doc2 only
         $this->assertCount(1, $results);
@@ -189,7 +219,7 @@ public function testObjectAttribute(): void
         try {
             // test -> not equal allows one value only
             $results = $database->find($collectionId, [
-                Query::notEqual('meta', [['age' => 26], ['age' => 27]])
+                Query::notEqual('meta', [['age' => 26], ['age' => 27]]),
             ]);
             $this->fail('No query thrown');
         } catch (Exception $e) {
@@ -201,10 +231,10 @@ public function testObjectAttribute(): void
             Query::notEqual('meta', [
                 'user' => [
                     'info' => [
-                        'country' => 'CA'
-                    ]
-                ]
-            ])
+                        'country' => 'CA',
+                    ],
+                ],
+            ]),
         ]);
         // Should return doc2 only
         $this->assertCount(1, $results);
@@ -214,24 +244,29 @@ public function testObjectAttribute(): void
         $fetchedDoc = $database->getDocument($collectionId, 'doc1');
         $this->assertEquals('doc1', $fetchedDoc->getId());
         $this->assertIsArray($fetchedDoc->getAttribute('meta'));
-        $this->assertEquals(26, $fetchedDoc->getAttribute('meta')['age']);
-        $this->assertEquals(['react', 'node', 'typescript'], $fetchedDoc->getAttribute('meta')['skills']);
-        $this->assertEquals('CA', $fetchedDoc->getAttribute('meta')['user']['info']['country']);
+        $fetchedMeta = $fetchedDoc->getArray('meta');
+        $this->assertEquals(26, $fetchedMeta['age']);
+        $this->assertEquals(['react', 'node', 'typescript'], $fetchedMeta['skills']);
+        $fetchedUser = $fetchedMeta['user'] ?? null;
+        $this->assertIsArray($fetchedUser);
+        $fetchedInfo = $fetchedUser['info'] ?? null;
+        $this->assertIsArray($fetchedInfo);
+        $this->assertEquals('CA', $fetchedInfo['country']);
 
         // Test 11b: Test Query::select to limit returned attributes
         $results = $database->find($collectionId, [
             Query::select(['$id', 'meta']),
-            Query::equal('meta', [['age' => 26]])
+            Query::equal('meta', [['age' => 26]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc1', $results[0]->getId());
         $this->assertIsArray($results[0]->getAttribute('meta'));
-        $this->assertEquals(26, $results[0]->getAttribute('meta')['age']);
+        $this->assertEquals(26, $results[0]->getArray('meta')['age']);
 
         // Test 11c: Test Query::select with only $id (exclude meta)
         $results = $database->find($collectionId, [
             Query::select(['$id']),
-            Query::equal('meta', [['age' => 30]])
+            Query::equal('meta', [['age' => 30]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc2', $results[0]->getId());
@@ -242,7 +277,7 @@ public function testObjectAttribute(): void
         $doc3 = $database->createDocument($collectionId, new Document([
             '$id' => 'doc3',
             '$permissions' => [Permission::read(Role::any())],
-            'meta' => null
+            'meta' => null,
         ]));
         $this->assertNull($doc3->getAttribute('meta'));
 
@@ -250,7 +285,7 @@ public function testObjectAttribute(): void
         $doc4 = $database->createDocument($collectionId, new Document([
             '$id' => 'doc4',
             '$permissions' => [Permission::read(Role::any())],
-            'meta' => []
+            'meta' => [],
         ]));
         $this->assertIsArray($doc4->getAttribute('meta'));
         $this->assertEmpty($doc4->getAttribute('meta'));
@@ -264,14 +299,14 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ],
         ]));
-        $this->assertEquals('deep_value', $doc5->getAttribute('meta')['level1']['level2']['level3']['level4']['level5']);
+        $this->assertEquals('deep_value', $this->nestedMetaValue($doc5->getArray('meta'), ['level1', 'level2', 'level3', 'level4', 'level5']));
 
         // Test 15: Query deeply nested structure
         $results = $database->find($collectionId, [
@@ -280,12 +315,12 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc5', $results[0]->getId());
@@ -297,12 +332,12 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
 
@@ -317,32 +352,32 @@ public function testObjectAttribute(): void
                 'boolean' => true,
                 'null_value' => null,
                 'array' => [1, 2, 3],
-                'object' => ['key' => 'value']
-            ]
+                'object' => ['key' => 'value'],
+            ],
         ]));
-        $this->assertEquals('text', $doc6->getAttribute('meta')['string']);
-        $this->assertEquals(42, $doc6->getAttribute('meta')['number']);
-        $this->assertEquals(3.14, $doc6->getAttribute('meta')['float']);
-        $this->assertTrue($doc6->getAttribute('meta')['boolean']);
-        $this->assertNull($doc6->getAttribute('meta')['null_value']);
+        $this->assertEquals('text', $doc6->getArray('meta')['string']);
+        $this->assertEquals(42, $doc6->getArray('meta')['number']);
+        $this->assertEquals(3.14, $doc6->getArray('meta')['float']);
+        $this->assertTrue($doc6->getArray('meta')['boolean']);
+        $this->assertNull($doc6->getArray('meta')['null_value']);
 
         // Test 18: Query with boolean value
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['boolean' => true]])
+            Query::equal('meta', [['boolean' => true]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc6', $results[0]->getId());
 
         // Test 19: Query with numeric value
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['number' => 42]])
+            Query::equal('meta', [['number' => 42]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc6', $results[0]->getId());
 
         // Test 20: Query with float value
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['float' => 3.14]])
+            Query::equal('meta', [['float' => 3.14]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc6', $results[0]->getId());
@@ -352,11 +387,11 @@ public function testObjectAttribute(): void
             '$id' => 'doc7',
             '$permissions' => [Permission::read(Role::any())],
             'meta' => [
-                'tags' => ['php', 'javascript', 'python', 'go', 'rust']
-            ]
+                'tags' => ['php', 'javascript', 'python', 'go', 'rust'],
+            ],
         ]));
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['tags' => 'rust']])
+            Query::contains('meta', [['tags' => 'rust']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc7', $results[0]->getId());
@@ -366,24 +401,24 @@ public function testObjectAttribute(): void
             '$id' => 'doc8',
             '$permissions' => [Permission::read(Role::any())],
             'meta' => [
-                'scores' => [85, 90, 95, 100]
-            ]
+                'scores' => [85, 90, 95, 100],
+            ],
         ]));
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['scores' => 95]])
+            Query::contains('meta', [['scores' => 95]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc8', $results[0]->getId());
 
         // Test 23: Negative test - contains query that shouldn't match
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['tags' => 'kotlin']])
+            Query::contains('meta', [['tags' => 'kotlin']]),
         ]);
         $this->assertCount(0, $results);
 
         // Test 23b: notContains should exclude doc7 (which has 'rust')
         $results = $database->find($collectionId, [
-            Query::notContains('meta', [['tags' => 'rust']])
+            Query::notContains('meta', [['tags' => 'rust']]),
         ]);
         // Should not include doc7; returns others (at least doc1, doc2, ...)
         $this->assertGreaterThanOrEqual(1, count($results));
@@ -402,24 +437,27 @@ public function testObjectAttribute(): void
                     [
                         'name' => 'Project A',
                         'technologies' => ['react', 'node'],
-                        'active' => true
+                        'active' => true,
                     ],
                     [
                         'name' => 'Project B',
                         'technologies' => ['vue', 'python'],
-                        'active' => false
-                    ]
+                        'active' => false,
+                    ],
                 ],
-                'company' => 'TechCorp'
-            ]
+                'company' => 'TechCorp',
+            ],
         ]));
-        $this->assertIsArray($doc9->getAttribute('meta')['projects']);
-        $this->assertCount(2, $doc9->getAttribute('meta')['projects']);
-        $this->assertEquals('Project A', $doc9->getAttribute('meta')['projects'][0]['name']);
+        $projects = $doc9->getArray('meta')['projects'] ?? null;
+        $this->assertIsArray($projects);
+        $this->assertCount(2, $projects);
+        $project = $projects[0] ?? null;
+        $this->assertIsArray($project);
+        $this->assertEquals('Project A', $project['name']);
 
         // Test 25: Query using equal with nested key
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['company' => 'TechCorp']])
+            Query::equal('meta', [['company' => 'TechCorp']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc9', $results[0]->getId());
@@ -431,15 +469,15 @@ public function testObjectAttribute(): void
                     [
                         'name' => 'Project A',
                         'technologies' => ['react', 'node'],
-                        'active' => true
+                        'active' => true,
                     ],
                     [
                         'name' => 'Project B',
                         'technologies' => ['vue', 'python'],
-                        'active' => false
-                    ]
-                ]
-            ]])
+                        'active' => false,
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc9', $results[0]->getId());
@@ -451,15 +489,15 @@ public function testObjectAttribute(): void
             'meta' => [
                 'description' => 'Test with "quotes" and \'apostrophes\'',
                 'emoji' => '🚀🎉',
-                'symbols' => '@#$%^&*()'
-            ]
+                'symbols' => '@#$%^&*()',
+            ],
         ]));
-        $this->assertEquals('Test with "quotes" and \'apostrophes\'', $doc10->getAttribute('meta')['description']);
-        $this->assertEquals('🚀🎉', $doc10->getAttribute('meta')['emoji']);
+        $this->assertEquals('Test with "quotes" and \'apostrophes\'', $doc10->getArray('meta')['description']);
+        $this->assertEquals('🚀🎉', $doc10->getArray('meta')['emoji']);
 
         // Test 27: Query with special characters
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['emoji' => '🚀🎉']])
+            Query::equal('meta', [['emoji' => '🚀🎉']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc10', $results[0]->getId());
@@ -471,19 +509,19 @@ public function testObjectAttribute(): void
             'meta' => [
                 'config' => [
                     'theme' => 'dark',
-                    'language' => 'en'
-                ]
-            ]
+                    'language' => 'en',
+                ],
+            ],
         ]));
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['config' => ['theme' => 'dark', 'language' => 'en']]])
+            Query::equal('meta', [['config' => ['theme' => 'dark', 'language' => 'en']]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc11', $results[0]->getId());
 
         // Test 29: Negative test - partial object match should still work (containment)
         $results = $database->find($collectionId, [
-            Query::equal('meta', [['config' => ['theme' => 'dark']]])
+            Query::equal('meta', [['config' => ['theme' => 'dark']]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc11', $results[0]->getId());
@@ -492,7 +530,7 @@ public function testObjectAttribute(): void
         $updatedDoc11 = $database->updateDocument($collectionId, 'doc11', new Document([
             '$id' => 'doc11',
             '$permissions' => [Permission::read(Role::any())],
-            'meta' => []
+            'meta' => [],
         ]));
         $this->assertIsArray($updatedDoc11->getAttribute('meta'));
         $this->assertEmpty($updatedDoc11->getAttribute('meta'));
@@ -505,16 +543,17 @@ public function testObjectAttribute(): void
                 'matrix' => [
                     [1, 2, 3],
                     [4, 5, 6],
-                    [7, 8, 9]
-                ]
-            ]
+                    [7, 8, 9],
+                ],
+            ],
         ]));
-        $this->assertIsArray($doc12->getAttribute('meta')['matrix']);
-        $this->assertEquals([1, 2, 3], $doc12->getAttribute('meta')['matrix'][0]);
+        $matrix = $doc12->getArray('meta')['matrix'] ?? null;
+        $this->assertIsArray($matrix);
+        $this->assertEquals([1, 2, 3], $matrix[0]);
 
         // Test 32: Contains query with nested array
         $results = $database->find($collectionId, [
-            Query::contains('meta', [['matrix' => [[4, 5, 6]]]])
+            Query::contains('meta', [['matrix' => [[4, 5, 6]]]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc12', $results[0]->getId());
@@ -522,13 +561,13 @@ public function testObjectAttribute(): void
         // Test 33: Test getDocument with various documents
         $fetchedDoc6 = $database->getDocument($collectionId, 'doc6');
         $this->assertEquals('doc6', $fetchedDoc6->getId());
-        $this->assertEquals('text', $fetchedDoc6->getAttribute('meta')['string']);
-        $this->assertEquals(42, $fetchedDoc6->getAttribute('meta')['number']);
-        $this->assertTrue($fetchedDoc6->getAttribute('meta')['boolean']);
+        $this->assertEquals('text', $fetchedDoc6->getArray('meta')['string']);
+        $this->assertEquals(42, $fetchedDoc6->getArray('meta')['number']);
+        $this->assertTrue($fetchedDoc6->getArray('meta')['boolean']);
 
         $fetchedDoc10 = $database->getDocument($collectionId, 'doc10');
-        $this->assertEquals('🚀🎉', $fetchedDoc10->getAttribute('meta')['emoji']);
-        $this->assertEquals('Test with "quotes" and \'apostrophes\'', $fetchedDoc10->getAttribute('meta')['description']);
+        $this->assertEquals('🚀🎉', $fetchedDoc10->getArray('meta')['emoji']);
+        $this->assertEquals('Test with "quotes" and \'apostrophes\'', $fetchedDoc10->getArray('meta')['description']);
 
         // Test 34: Test Query::select with complex nested structures
         $results = $database->find($collectionId, [
@@ -538,21 +577,21 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc5', $results[0]->getId());
-        $this->assertEquals('deep_value', $results[0]->getAttribute('meta')['level1']['level2']['level3']['level4']['level5']);
+        $this->assertEquals('deep_value', $this->nestedMetaValue($results[0]->getArray('meta'), ['level1', 'level2', 'level3', 'level4', 'level5']));
 
         // Test 35: Test selecting multiple documents and verifying object attributes
         $allDocs = $database->find($collectionId, [
             Query::select(['$id', 'meta']),
-            Query::limit(25)
+            Query::limit(25),
         ]);
         $this->assertGreaterThan(10, count($allDocs));
 
@@ -567,11 +606,11 @@ public function testObjectAttribute(): void
         // Test 36: Test Query::select with only meta attribute
         $results = $database->find($collectionId, [
             Query::select(['meta']),
-            Query::equal('meta', [['tags' => ['php', 'javascript', 'python', 'go', 'rust']]])
+            Query::equal('meta', [['tags' => ['php', 'javascript', 'python', 'go', 'rust']]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertIsArray($results[0]->getAttribute('meta'));
-        $this->assertEquals(['php', 'javascript', 'python', 'go', 'rust'], $results[0]->getAttribute('meta')['tags']);
+        $this->assertEquals(['php', 'javascript', 'python', 'go', 'rust'], $results[0]->getArray('meta')['tags']);
 
         // Clean up
         $database->deleteCollection($collectionId);
@@ -582,18 +621,18 @@ public function testObjectAttributeGinIndex(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForObjectIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::ObjectIndexes)) {
             $this->markTestSkipped('Adapter does not support object indexes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create object attribute
-        $this->createAttribute($database, $collectionId, 'data', Database::VAR_OBJECT, 0, false);
+        $this->createAttribute($database, $collectionId, 'data', ColumnType::Object, 0, false);
 
         // Test 1: Create Object index on object attribute
-        $ginIndex = $database->createIndex($collectionId, 'idx_data_gin', Database::INDEX_OBJECT, ['data']);
+        $ginIndex = $database->createIndex($collectionId, Index::object(key: 'idx_data_gin', attributes: ['data']));
         $this->assertTrue($ginIndex);
 
         // Test 2: Create documents with JSONB data
@@ -604,10 +643,10 @@ public function testObjectAttributeGinIndex(): void
                 'tags' => ['php', 'javascript', 'python'],
                 'config' => [
                     'env' => 'production',
-                    'debug' => false
+                    'debug' => false,
                 ],
-                'version' => '1.0.0'
-            ]
+                'version' => '1.0.0',
+            ],
         ]));
 
         $doc2 = $database->createDocument($collectionId, new Document([
@@ -617,39 +656,39 @@ public function testObjectAttributeGinIndex(): void
                 'tags' => ['java', 'kotlin', 'scala'],
                 'config' => [
                     'env' => 'development',
-                    'debug' => true
+                    'debug' => true,
                 ],
-                'version' => '2.0.0'
-            ]
+                'version' => '2.0.0',
+            ],
         ]));
 
         // Test 3: Query with equal on indexed JSONB column
         $results = $database->find($collectionId, [
-            Query::equal('data', [['config' => ['env' => 'production']]])
+            Query::equal('data', [['config' => ['env' => 'production']]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('gin1', $results[0]->getId());
 
         // Test 4: Query with contains on indexed JSONB column
         $results = $database->find($collectionId, [
-            Query::contains('data', [['tags' => 'php']])
+            Query::contains('data', [['tags' => 'php']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('gin1', $results[0]->getId());
 
         // Test 5: Verify Object index improves performance for containment queries
         $results = $database->find($collectionId, [
-            Query::contains('data', [['tags' => 'kotlin']])
+            Query::contains('data', [['tags' => 'kotlin']]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('gin2', $results[0]->getId());
 
         // Test 6: Try to create Object index on non-object attribute (should fail)
-        $this->createAttribute($database, $collectionId, 'name', Database::VAR_STRING, 255, false);
+        $this->createAttribute($database, $collectionId, 'name', ColumnType::String, 255, false);
 
         $exceptionThrown = false;
         try {
-            $database->createIndex($collectionId, 'idx_name_gin', Database::INDEX_OBJECT, ['name']);
+            $database->createIndex($collectionId, Index::object(key: 'idx_name_gin', attributes: ['name']));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -658,11 +697,11 @@ public function testObjectAttributeGinIndex(): void
         $this->assertTrue($exceptionThrown, 'Expected Index exception for Object index on non-object attribute');
 
         // Test 7: Try to create Object index on multiple attributes (should fail)
-        $this->createAttribute($database, $collectionId, 'metadata', Database::VAR_OBJECT, 0, false);
+        $this->createAttribute($database, $collectionId, 'metadata', ColumnType::Object, 0, false);
 
         $exceptionThrown = false;
         try {
-            $database->createIndex($collectionId, 'idx_multi_gin', Database::INDEX_OBJECT, ['data', 'metadata']);
+            $database->createIndex($collectionId, Index::object(key: 'idx_multi_gin', attributes: ['data', 'metadata']));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -673,7 +712,7 @@ public function testObjectAttributeGinIndex(): void
         // Test 8: Try to create Object index with orders (should fail)
         $exceptionThrown = false;
         try {
-            $database->createIndex($collectionId, 'idx_ordered_gin', Database::INDEX_OBJECT, ['metadata'], [], [Database::ORDER_ASC]);
+            $database->createIndex($collectionId, Index::object(key: 'idx_ordered_gin', attributes: ['metadata'], orders: [Order::Asc]));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -685,297 +724,18 @@ public function testObjectAttributeGinIndex(): void
         $database->deleteCollection($collectionId);
     }
 
-    public function testObjectAttributeInvalidCases(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Skip test if adapter doesn't support JSONB
-        if (!$database->getAdapter()->getSupportForObject() || !$database->getAdapter()->getSupportForAttributes()) {
-            $this->markTestSkipped('Adapter does not support object attributes');
-        }
-
-        $collectionId = ID::unique();
-        $database->createCollection($collectionId);
-
-        // Create object attribute
-        $this->createAttribute($database, $collectionId, 'meta', Database::VAR_OBJECT, 0, false);
-
-        // Test 1: Try to create document with string instead of object (should fail)
-        $exceptionThrown = false;
-        try {
-            $database->createDocument($collectionId, new Document([
-                '$id' => 'invalid1',
-                '$permissions' => [Permission::read(Role::any())],
-                'meta' => 'this is a string not an object'
-            ]));
-        } catch (\Exception $e) {
-            $exceptionThrown = true;
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-        $this->assertTrue($exceptionThrown, 'Expected Structure exception for string value');
-
-        // Test 2: Try to create document with integer instead of object (should fail)
-        $exceptionThrown = false;
-        try {
-            $database->createDocument($collectionId, new Document([
-                '$id' => 'invalid2',
-                '$permissions' => [Permission::read(Role::any())],
-                'meta' => 12345
-            ]));
-        } catch (\Exception $e) {
-            $exceptionThrown = true;
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-        $this->assertTrue($exceptionThrown, 'Expected Structure exception for integer value');
-
-        // Test 3: Try to create document with boolean instead of object (should fail)
-        $exceptionThrown = false;
-        try {
-            $database->createDocument($collectionId, new Document([
-                '$id' => 'invalid3',
-                '$permissions' => [Permission::read(Role::any())],
-                'meta' => true
-            ]));
-        } catch (\Exception $e) {
-            $exceptionThrown = true;
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-        $this->assertTrue($exceptionThrown, 'Expected Structure exception for boolean value');
-
-        // Test 4: Create valid document for query tests
-        $database->createDocument($collectionId, new Document([
-            '$id' => 'valid1',
-            '$permissions' => [Permission::read(Role::any())],
-            'meta' => [
-                'name' => 'John',
-                'age' => 30,
-                'settings' => [
-                    'notifications' => true,
-                    'theme' => 'dark'
-                ]
-            ]
-        ]));
-
-        // Test 5: Query with non-matching nested structure
-        $results = $database->find($collectionId, [
-            Query::equal('meta', [['settings' => ['notifications' => false]]])
-        ]);
-        $this->assertCount(0, $results, 'Should not match when nested value differs');
-
-        // Test 6: Query with non-existent key
-        $results = $database->find($collectionId, [
-            Query::equal('meta', [['nonexistent' => 'value']])
-        ]);
-        $this->assertCount(0, $results, 'Should not match non-existent keys');
-
-        // Test 7: Contains query with non-matching array element
-        $database->createDocument($collectionId, new Document([
-            '$id' => 'valid2',
-            '$permissions' => [Permission::read(Role::any())],
-            'meta' => [
-                'fruits' => ['apple', 'banana', 'orange']
-            ]
-        ]));
-        $results = $database->find($collectionId, [
-            Query::contains('meta', [['fruits' => 'grape']])
-        ]);
-        $this->assertCount(0, $results, 'Should not match non-existent array element');
-
-        // Test 8: Test order preservation in nested objects
-        $doc = $database->createDocument($collectionId, new Document([
-            '$id' => 'order_test',
-            '$permissions' => [Permission::read(Role::any())],
-            'meta' => [
-                'z_last' => 'value',
-                'a_first' => 'value',
-                'm_middle' => 'value'
-            ]
-        ]));
-        $meta = $doc->getAttribute('meta');
-        $this->assertIsArray($meta);
-        // Note: JSON objects don't guarantee key order, but we can verify all keys exist
-        $this->assertArrayHasKey('z_last', $meta);
-        $this->assertArrayHasKey('a_first', $meta);
-        $this->assertArrayHasKey('m_middle', $meta);
-
-        // Test 9: Test with very large nested structure
-        $largeStructure = [];
-        for ($i = 0; $i < 50; $i++) {
-            $largeStructure["key_$i"] = [
-                'id' => $i,
-                'name' => "Item $i",
-                'values' => range(1, 10)
-            ];
-        }
-        $docLarge = $database->createDocument($collectionId, new Document([
-            '$id' => 'large_structure',
-            '$permissions' => [Permission::read(Role::any())],
-            'meta' => $largeStructure
-        ]));
-        $this->assertIsArray($docLarge->getAttribute('meta'));
-        $this->assertCount(50, $docLarge->getAttribute('meta'));
-
-        // Test 10: Query within large structure
-        $results = $database->find($collectionId, [
-            Query::equal('meta', [['key_25' => ['id' => 25, 'name' => 'Item 25', 'values' => range(1, 10)]]])
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('large_structure', $results[0]->getId());
-
-        // Test 11: Test getDocument with large structure
-        $fetchedLargeDoc = $database->getDocument($collectionId, 'large_structure');
-        $this->assertEquals('large_structure', $fetchedLargeDoc->getId());
-        $this->assertIsArray($fetchedLargeDoc->getAttribute('meta'));
-        $this->assertCount(50, $fetchedLargeDoc->getAttribute('meta'));
-        $this->assertEquals(25, $fetchedLargeDoc->getAttribute('meta')['key_25']['id']);
-        $this->assertEquals('Item 25', $fetchedLargeDoc->getAttribute('meta')['key_25']['name']);
-
-        // Test 12: Test Query::select with valid document
-        $results = $database->find($collectionId, [
-            Query::select(['$id', 'meta']),
-            Query::equal('meta', [['name' => 'John']])
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('valid1', $results[0]->getId());
-        $this->assertIsArray($results[0]->getAttribute('meta'));
-        $this->assertEquals('John', $results[0]->getAttribute('meta')['name']);
-        $this->assertEquals(30, $results[0]->getAttribute('meta')['age']);
-
-        // Test 13: Test getDocument returns proper structure
-        $fetchedValid1 = $database->getDocument($collectionId, 'valid1');
-        $this->assertEquals('valid1', $fetchedValid1->getId());
-        $this->assertIsArray($fetchedValid1->getAttribute('meta'));
-        $this->assertEquals('John', $fetchedValid1->getAttribute('meta')['name']);
-        $this->assertTrue($fetchedValid1->getAttribute('meta')['settings']['notifications']);
-        $this->assertEquals('dark', $fetchedValid1->getAttribute('meta')['settings']['theme']);
-
-        // Test 14: Test Query::select excluding meta
-        $results = $database->find($collectionId, [
-            Query::select(['$id', '$permissions']),
-            Query::equal('meta', [['fruits' => ['apple', 'banana', 'orange']]])
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('valid2', $results[0]->getId());
-        // Meta should be empty when not selected
-        $this->assertEmpty($results[0]->getAttribute('meta'));
-
-        // Test 15: Test getDocument with non-existent ID returns empty document
-        $nonExistent = $database->getDocument($collectionId, 'does_not_exist');
-        $this->assertTrue($nonExistent->isEmpty());
-
-        // Test 16: with multiple json
-        $defaultSettings = ['config' => ['theme' => 'light', 'lang' => 'en']];
-        $this->createAttribute($database, $collectionId, 'settings', Database::VAR_OBJECT, 0, false, $defaultSettings);
-        $database->createDocument($collectionId, new Document(['$permissions' => [Permission::read(Role::any())]]));
-        $database->createDocument($collectionId, new Document(['settings' => ['config' => ['theme' => 'dark', 'lang' => 'en']], '$permissions' => [Permission::read(Role::any())]]));
-        $results = $database->find($collectionId, [
-            Query::equal('settings', [['config' => ['theme' => 'light']], ['config' => ['theme' => 'dark']]])
-        ]);
-        $this->assertCount(2, $results);
-
-        $results = $database->find($collectionId, [
-            // Containment: both documents have config.lang == 'en'
-            Query::contains('settings', [['config' => ['lang' => 'en']]])
-        ]);
-        $this->assertCount(2, $results);
-
-        // Clean up
-        $database->deleteCollection($collectionId);
-    }
-
-    public function testObjectAttributeDefaults(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        // Skip test if adapter doesn't support JSONB
-        if (!$database->getAdapter()->getSupportForObject() || !$database->getAdapter()->getSupportForAttributes()) {
-            $this->markTestSkipped('Adapter does not support object attributes');
-        }
-
-        $collectionId = ID::unique();
-        $database->createCollection($collectionId);
-
-        // 1) Default empty object
-        $this->createAttribute($database, $collectionId, 'metaDefaultEmpty', Database::VAR_OBJECT, 0, false, []);
-
-        // 2) Default nested object
-        $defaultSettings = ['config' => ['theme' => 'light', 'lang' => 'en']];
-        $this->createAttribute($database, $collectionId, 'settings', Database::VAR_OBJECT, 0, false, $defaultSettings);
-
-        // 3) Required without default (should fail when missing)
-        $this->createAttribute($database, $collectionId, 'profile', Database::VAR_OBJECT, 0, true, null);
-
-        // 4) Required with default (should auto-populate)
-        $this->createAttribute($database, $collectionId, 'profile2', Database::VAR_OBJECT, 0, false, ['name' => 'anon']);
-
-        // 5) Explicit null default
-        $this->createAttribute($database, $collectionId, 'misc', Database::VAR_OBJECT, 0, false, null);
-
-        // Create document missing all above attributes
-        $exceptionThrown = false;
-        try {
-            $doc = $database->createDocument($collectionId, new Document([
-                '$id' => 'def1',
-                '$permissions' => [Permission::read(Role::any())],
-            ]));
-            // Should not reach here because 'profile' is required and missing
-        } catch (\Exception $e) {
-            $exceptionThrown = true;
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-        $this->assertTrue($exceptionThrown, 'Expected Structure exception for missing required object attribute');
-
-        // Create document providing required 'profile' but omit others to test defaults
-        $doc = $database->createDocument($collectionId, new Document([
-            '$id' => 'def2',
-            '$permissions' => [Permission::read(Role::any())],
-            'profile' => ['name' => 'provided'],
-        ]));
-
-        // metaDefaultEmpty should default to []
-        $this->assertIsArray($doc->getAttribute('metaDefaultEmpty'));
-        $this->assertEmpty($doc->getAttribute('metaDefaultEmpty'));
-
-        // settings should default to nested object
-        $this->assertIsArray($doc->getAttribute('settings'));
-        $this->assertEquals('light', $doc->getAttribute('settings')['config']['theme']);
-        $this->assertEquals('en', $doc->getAttribute('settings')['config']['lang']);
-
-        // profile provided explicitly
-        $this->assertEquals('provided', $doc->getAttribute('profile')['name']);
-
-        // profile2 required with default should be auto-populated
-        $this->assertIsArray($doc->getAttribute('profile2'));
-        $this->assertEquals('anon', $doc->getAttribute('profile2')['name']);
-
-        // misc explicit null default remains null when omitted
-        $this->assertNull($doc->getAttribute('misc'));
-
-        // Query defaults work
-        $results = $database->find($collectionId, [
-            Query::equal('settings', [['config' => ['theme' => 'light']]])
-        ]);
-        $this->assertCount(1, $results);
-        $this->assertEquals('def2', $results[0]->getId());
-
-        // Clean up
-        $database->deleteCollection($collectionId);
-    }
-
     public function testObjectAttributeIntegersBeyondInt32(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForObject()) {
+        if (!$database->getAdapter()->supports(Capability::Objects)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
-        $this->createAttribute($database, $collectionId, 'meta', Database::VAR_OBJECT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $this->createAttribute($database, $collectionId, 'meta', ColumnType::Object, 0, false);
 
         // An object attribute has no per-key schema, so there is no typed cast
         // to lean on: whatever the adapter decodes is what reaches the client.
@@ -991,10 +751,13 @@ public function testObjectAttributeIntegersBeyondInt32(): void
 
         $database->purgeCachedDocument($collectionId, 'bigInts');
         $meta = $database->getDocument($collectionId, 'bigInts')->getAttribute('meta');
+        $this->assertIsArray($meta);
+        $nested = $meta['nested'] ?? null;
+        $this->assertIsArray($nested);
 
         $this->assertIsInt($meta['small']);
         $this->assertIsInt($meta['count']);
-        $this->assertIsInt($meta['nested']['deep']);
+        $this->assertIsInt($nested['deep']);
         $this->assertEquals([
             'small' => -42,
             'count' => -3408048000,
@@ -1014,13 +777,13 @@ public function testObjectAttributeEmptyObject(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForObject()) {
+        if (!$database->getAdapter()->supports(Capability::Objects)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
-        $this->createAttribute($database, $collectionId, 'meta', Database::VAR_OBJECT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $this->createAttribute($database, $collectionId, 'meta', ColumnType::Object, 0, false);
 
         $created = $database->createDocument($collectionId, new Document([
             '$id' => 'emptyObject',
@@ -1060,13 +823,13 @@ public function testObjectAttributeNestedEmptyObjects(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForObject()) {
+        if (!$database->getAdapter()->supports(Capability::Objects)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
-        $this->createAttribute($database, $collectionId, 'meta', Database::VAR_OBJECT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $this->createAttribute($database, $collectionId, 'meta', ColumnType::Object, 0, false);
 
         $created = $database->createDocument($collectionId, new Document([
             '$id' => 'nestedEmptyObjects',
@@ -1078,28 +841,38 @@ public function testObjectAttributeNestedEmptyObjects(): void
             ],
         ]));
         $createdMeta = $created->getAttribute('meta');
+        $this->assertIsArray($createdMeta);
+        $createdArray = $createdMeta['arr'] ?? null;
+        $this->assertIsArray($createdArray);
         $this->assertSame('{}', json_encode($createdMeta['inner']));
-        $this->assertSame('{}', json_encode($createdMeta['arr'][0]));
-        $this->assertSame('{"x":1}', json_encode($createdMeta['arr'][1]));
+        $this->assertSame('{}', json_encode($createdArray[0]));
+        $this->assertSame('{"x":1}', json_encode($createdArray[1]));
         $this->assertSame('[]', json_encode($createdMeta['emptyArray']));
 
         $database->purgeCachedDocument($collectionId, 'nestedEmptyObjects');
         $readMeta = $database->getDocument($collectionId, 'nestedEmptyObjects')->getAttribute('meta');
+        $this->assertIsArray($readMeta);
+        $readArray = $readMeta['arr'] ?? null;
+        $this->assertIsArray($readArray);
         $this->assertSame('{}', json_encode($readMeta['inner']));
-        $this->assertSame('{}', json_encode($readMeta['arr'][0]));
-        $this->assertSame('{"x":1}', json_encode($readMeta['arr'][1]));
+        $this->assertSame('{}', json_encode($readArray[0]));
+        $this->assertSame('{"x":1}', json_encode($readArray[1]));
         $this->assertSame('[]', json_encode($readMeta['emptyArray']));
 
         $cached = $database->getDocument($collectionId, 'nestedEmptyObjects');
         $cachedMeta = $cached->getAttribute('meta');
+        $this->assertIsArray($cachedMeta);
+        $cachedArray = $cachedMeta['arr'] ?? null;
+        $this->assertIsArray($cachedArray);
         $this->assertSame('{}', json_encode($cachedMeta['inner']));
-        $this->assertSame('{}', json_encode($cachedMeta['arr'][0]));
-        $this->assertSame('{"x":1}', json_encode($cachedMeta['arr'][1]));
+        $this->assertSame('{}', json_encode($cachedArray[0]));
+        $this->assertSame('{"x":1}', json_encode($cachedArray[1]));
         $this->assertSame('[]', json_encode($cachedMeta['emptyArray']));
 
         $updatedMeta = $cachedMeta;
         $updatedMeta['inner'] = new \stdClass();
-        $updatedMeta['arr'][0] = new \stdClass();
+        $cachedArray[0] = new \stdClass();
+        $updatedMeta['arr'] = $cachedArray;
         $updated = $database->updateDocument($collectionId, 'nestedEmptyObjects', new Document([
             'meta' => $updatedMeta,
         ]));
@@ -1114,17 +887,18 @@ public function testMetadataWithVector(): void
         $database = static::getDatabase();
 
         // Skip if adapter doesn't support either vectors or object attributes
-        if (!$database->getAdapter()->getSupportForVectors() || !$database->getAdapter()->getSupportForObject()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors) || ! $database->getAdapter()->supports(Capability::Objects)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Attributes: 3D vector and nested metadata object
-        $this->createAttribute($database, $collectionId, 'embedding', Database::VAR_VECTOR, 3, true);
-        $this->createAttribute($database, $collectionId, 'metadata', Database::VAR_OBJECT, 0, false);
+        $this->createAttribute($database, $collectionId, 'embedding', ColumnType::Vector, 3, true);
+        $this->createAttribute($database, $collectionId, 'metadata', ColumnType::Object, 0, false);
 
         // Seed documents
         $docA = $database->createDocument($collectionId, new Document([
@@ -1136,20 +910,20 @@ public function testMetadataWithVector(): void
                     'user' => [
                         'info' => [
                             'country' => 'IN',
-                            'score' => 100
-                        ]
-                    ]
+                            'score' => 100,
+                        ],
+                    ],
                 ],
                 'tags' => ['ai', 'ml', 'db'],
                 'settings' => [
                     'prefs' => [
                         'theme' => 'dark',
                         'features' => [
-                            'experimental' => true
-                        ]
-                    ]
-                ]
-            ]
+                            'experimental' => true,
+                        ],
+                    ],
+                ],
+            ],
         ]));
 
         $docB = $database->createDocument($collectionId, new Document([
@@ -1161,17 +935,17 @@ public function testMetadataWithVector(): void
                     'user' => [
                         'info' => [
                             'country' => 'US',
-                            'score' => 80
-                        ]
-                    ]
+                            'score' => 80,
+                        ],
+                    ],
                 ],
                 'tags' => ['search', 'analytics'],
                 'settings' => [
                     'prefs' => [
-                        'theme' => 'light'
-                    ]
-                ]
-            ]
+                        'theme' => 'light',
+                    ],
+                ],
+            ],
         ]));
 
         $docC = $database->createDocument($collectionId, new Document([
@@ -1183,26 +957,26 @@ public function testMetadataWithVector(): void
                     'user' => [
                         'info' => [
                             'country' => 'CA',
-                            'score' => 60
-                        ]
-                    ]
+                            'score' => 60,
+                        ],
+                    ],
                 ],
                 'tags' => ['ml', 'cv'],
                 'settings' => [
                     'prefs' => [
                         'theme' => 'dark',
                         'features' => [
-                            'experimental' => false
-                        ]
-                    ]
-                ]
-            ]
+                            'experimental' => false,
+                        ],
+                    ],
+                ],
+            ],
         ]));
 
         // 1) Vector similarity: closest to [0.0, 0.0, 1.0] should be vecA
         $results = $database->find($collectionId, [
             Query::vectorCosine('embedding', [0.0, 0.0, 1.0]),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecA', $results[0]->getId());
@@ -1213,11 +987,11 @@ public function testMetadataWithVector(): void
                 'profile' => [
                     'user' => [
                         'info' => [
-                            'country' => 'IN'
-                        ]
-                    ]
-                ]
-            ]])
+                            'country' => 'IN',
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecA', $results[0]->getId());
@@ -1225,8 +999,8 @@ public function testMetadataWithVector(): void
         // 3) Contains on nested array inside metadata
         $results = $database->find($collectionId, [
             Query::contains('metadata', [[
-                'tags' => 'ml'
-            ]])
+                'tags' => 'ml',
+            ]]),
         ]);
         $this->assertCount(2, $results); // vecA, vecC both have 'ml' in tags
 
@@ -1236,11 +1010,11 @@ public function testMetadataWithVector(): void
             Query::equal('metadata', [[
                 'settings' => [
                     'prefs' => [
-                        'theme' => 'light'
-                    ]
-                ]
+                        'theme' => 'light',
+                    ],
+                ],
             ]]),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecB', $results[0]->getId());
@@ -1251,11 +1025,11 @@ public function testMetadataWithVector(): void
                 'settings' => [
                     'prefs' => [
                         'features' => [
-                            'experimental' => true
-                        ]
-                    ]
-                ]
-            ]])
+                            'experimental' => true,
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecA', $results[0]->getId());
@@ -1269,26 +1043,25 @@ public function testNestedObjectAttributeIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->markTestSkipped('Adapter does not support attributes (schemaful required for nested object attribute indexes)');
         }
 
-        if (!$database->getAdapter()->getSupportForObjectIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::ObjectIndexes)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Base attributes
-        $this->createAttribute($database, $collectionId, 'profile', Database::VAR_OBJECT, 0, false);
-        $this->createAttribute($database, $collectionId, 'name', Database::VAR_STRING, 255, false);
+        $this->createAttribute($database, $collectionId, 'profile', ColumnType::Object, 0, false);
+        $this->createAttribute($database, $collectionId, 'name', ColumnType::String, 255, false);
 
         // 1) KEY index on a nested object path (dot notation)
 
-
         // 2) UNIQUE index on a nested object path should enforce uniqueness on insert
-        $created = $database->createIndex($collectionId, 'idx_profile_email_unique', Database::INDEX_UNIQUE, ['profile.user.email']);
+        $created = $database->createIndex($collectionId, Index::unique(key: 'idx_profile_email_unique', attributes: ['profile.user.email']));
         $this->assertTrue($created);
 
         $database->createDocument($collectionId, new Document([
@@ -1298,10 +1071,10 @@ public function testNestedObjectAttributeIndexes(): void
                 'user' => [
                     'email' => 'a@example.com',
                     'info' => [
-                        'country' => 'IN'
-                    ]
-                ]
-            ]
+                        'country' => 'IN',
+                    ],
+                ],
+            ],
         ]));
 
         try {
@@ -1312,10 +1085,10 @@ public function testNestedObjectAttributeIndexes(): void
                     'user' => [
                         'email' => 'a@example.com', // duplicate
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]));
             $this->fail('Expected Duplicate exception for UNIQUE index on nested object path');
         } catch (Exception $e) {
@@ -1324,14 +1097,14 @@ public function testNestedObjectAttributeIndexes(): void
 
         // 3) INDEX_OBJECT must NOT be allowed on nested paths
         try {
-            $database->createIndex($collectionId, 'idx_profile_nested_object', Database::INDEX_OBJECT, ['profile.user.email']);
+            $database->createIndex($collectionId, Index::object(key: 'idx_profile_nested_object', attributes: ['profile.user.email']));
         } catch (Exception $e) {
             $this->assertInstanceOf(IndexException::class, $e);
         }
 
         // 4) Nested path indexes must only be allowed when base attribute is VAR_OBJECT
         try {
-            $database->createIndex($collectionId, 'idx_name_nested', Database::INDEX_KEY, ['name.first']);
+            $database->createIndex($collectionId, Index::key(key: 'idx_name_nested', attributes: ['name.first']));
             $this->fail('Expected Type exception for nested index on non-object base attribute');
         } catch (Exception $e) {
             $this->assertInstanceOf(IndexException::class, $e);
@@ -1345,23 +1118,23 @@ public function testQueryNestedAttribute(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->markTestSkipped('Adapter does not support attributes (schemaful required for nested object attribute indexes)');
         }
 
-        if (!$database->getAdapter()->getSupportForObjectIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::ObjectIndexes)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Base attributes
-        $this->createAttribute($database, $collectionId, 'profile', Database::VAR_OBJECT, 0, false);
-        $this->createAttribute($database, $collectionId, 'name', Database::VAR_STRING, 255, false);
+        $this->createAttribute($database, $collectionId, 'profile', ColumnType::Object, 0, false);
+        $this->createAttribute($database, $collectionId, 'name', ColumnType::String, 255, false);
 
         // Create index on nested email path
-        $created = $database->createIndex($collectionId, 'idx_profile_email', Database::INDEX_KEY, ['profile.user.email']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_profile_email', attributes: ['profile.user.email']));
         $this->assertTrue($created);
 
         // Seed documents with different nested values
@@ -1374,11 +1147,11 @@ public function testQueryNestedAttribute(): void
                         'email' => 'alice@example.com',
                         'info' => [
                             'country' => 'IN',
-                            'city' => 'BLR'
-                        ]
-                    ]
+                            'city' => 'BLR',
+                        ],
+                    ],
                 ],
-                'name' => 'Alice'
+                'name' => 'Alice',
             ]),
             new Document([
                 '$id' => 'd2',
@@ -1388,11 +1161,11 @@ public function testQueryNestedAttribute(): void
                         'email' => 'bob@example.com',
                         'info' => [
                             'country' => 'US',
-                            'city' => 'NYC'
-                        ]
-                    ]
+                            'city' => 'NYC',
+                        ],
+                    ],
                 ],
-                'name' => 'Bob'
+                'name' => 'Bob',
             ]),
             new Document([
                 '$id' => 'd3',
@@ -1402,38 +1175,38 @@ public function testQueryNestedAttribute(): void
                         'email' => 'carol@test.org',
                         'info' => [
                             'country' => 'CA',
-                            'city' => 'TOR'
-                        ]
-                    ]
+                            'city' => 'TOR',
+                        ],
+                    ],
                 ],
-                'name' => 'Carol'
-            ])
+                'name' => 'Carol',
+            ]),
         ]);
 
         // Equal on nested email
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['bob@example.com'])
+            Query::equal('profile.user.email', ['bob@example.com']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d2', $results[0]->getId());
 
         // Starts with on nested email
         $results = $database->find($collectionId, [
-            Query::startsWith('profile.user.email', 'alice@')
+            Query::startsWith('profile.user.email', 'alice@'),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d1', $results[0]->getId());
 
         // Ends with on nested email
         $results = $database->find($collectionId, [
-            Query::endsWith('profile.user.email', 'test.org')
+            Query::endsWith('profile.user.email', 'test.org'),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d3', $results[0]->getId());
 
         // Contains on nested country (as text)
         $results = $database->find($collectionId, [
-            Query::contains('profile.user.info.country', ['US'])
+            Query::contains('profile.user.info.country', ['US']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d2', $results[0]->getId());
@@ -1443,7 +1216,7 @@ public function testQueryNestedAttribute(): void
             Query::and([
                 Query::equal('profile.user.info.country', ['IN']),
                 Query::endsWith('profile.user.email', 'example.com'),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d1', $results[0]->getId());
@@ -1453,7 +1226,7 @@ public function testQueryNestedAttribute(): void
             Query::or([
                 Query::equal('profile.user.info.country', ['CA']),
                 Query::startsWith('profile.user.email', 'bob@'),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
         $ids = \array_map(fn (Document $d) => $d->getId(), $results);
@@ -1462,7 +1235,7 @@ public function testQueryNestedAttribute(): void
 
         // NOT: exclude emails ending with example.com
         $results = $database->find($collectionId, [
-            Query::notEndsWith('profile.user.email', 'example.com')
+            Query::notEndsWith('profile.user.email', 'example.com'),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('d3', $results[0]->getId());
@@ -1475,20 +1248,20 @@ public function testNestedObjectAttributeEdgeCases(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForObject()) {
+        if (! $database->getAdapter()->supports(Capability::Objects)) {
             $this->markTestSkipped('Adapter does not support object attributes');
         }
 
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Base attributes
-        $this->createAttribute($database, $collectionId, 'profile', Database::VAR_OBJECT, 0, false);
-        $this->createAttribute($database, $collectionId, 'name', Database::VAR_STRING, 255, false);
-        $this->createAttribute($database, $collectionId, 'age', Database::VAR_INTEGER, 0, false);
+        $this->createAttribute($database, $collectionId, 'profile', ColumnType::Object, 0, false);
+        $this->createAttribute($database, $collectionId, 'name', ColumnType::String, 255, false);
+        $this->createAttribute($database, $collectionId, 'age', ColumnType::Integer, 0, false);
 
         // Edge Case 1: Deep nesting (5 levels deep)
-        $created = $database->createIndex($collectionId, 'idx_deep_nest', Database::INDEX_KEY, ['profile.level1.level2.level3.level4.value']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_deep_nest', attributes: ['profile.level1.level2.level3.level4.value']));
         $this->assertTrue($created);
 
         $database->createDocuments($collectionId, [
@@ -1500,12 +1273,12 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'level2' => [
                             'level3' => [
                                 'level4' => [
-                                    'value' => 'deep_value_1'
-                                ]
-                            ]
-                        ]
-                    ]
-                ]
+                                    'value' => 'deep_value_1',
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'deep2',
@@ -1515,19 +1288,19 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'level2' => [
                             'level3' => [
                                 'level4' => [
-                                    'value' => 'deep_value_2'
-                                ]
-                            ]
-                        ]
-                    ]
-                ]
-            ])
+                                    'value' => 'deep_value_2',
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             try {
                 $database->find($collectionId, [
-                    Query::equal('profile.level1.level2.level3.level4.value', [10])
+                    Query::equal('profile.level1.level2.level3.level4.value', [10]),
                 ]);
                 $this->fail('Expected nesting as string');
             } catch (Exception $e) {
@@ -1537,17 +1310,17 @@ public function testNestedObjectAttributeEdgeCases(): void
         }
 
         $results = $database->find($collectionId, [
-            Query::equal('profile.level1.level2.level3.level4.value', ['deep_value_1'])
+            Query::equal('profile.level1.level2.level3.level4.value', ['deep_value_1']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('deep1', $results[0]->getId());
 
         // Edge Case 2: Multiple nested indexes on same base attribute
-        $created = $database->createIndex($collectionId, 'idx_email', Database::INDEX_KEY, ['profile.user.email']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_email', attributes: ['profile.user.email']));
         $this->assertTrue($created);
-        $created = $database->createIndex($collectionId, 'idx_country', Database::INDEX_KEY, ['profile.user.info.country']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_country', attributes: ['profile.user.info.country']));
         $this->assertTrue($created);
-        $created = $database->createIndex($collectionId, 'idx_city', Database::INDEX_KEY, ['profile.user.info.city']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_city', attributes: ['profile.user.info.city']));
         $this->assertTrue($created);
 
         $database->createDocuments($collectionId, [
@@ -1559,10 +1332,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'multi1@test.com',
                         'info' => [
                             'country' => 'US',
-                            'city' => 'NYC'
-                        ]
-                    ]
-                ]
+                            'city' => 'NYC',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'multi2',
@@ -1572,30 +1345,30 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'multi2@test.com',
                         'info' => [
                             'country' => 'CA',
-                            'city' => 'TOR'
-                        ]
-                    ]
-                ]
-            ])
+                            'city' => 'TOR',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Query using first nested index
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['multi1@test.com'])
+            Query::equal('profile.user.email', ['multi1@test.com']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('multi1', $results[0]->getId());
 
         // Query using second nested index
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.info.country', ['US'])
+            Query::equal('profile.user.info.country', ['US']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('multi1', $results[0]->getId());
 
         // Query using third nested index
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.info.city', ['TOR'])
+            Query::equal('profile.user.info.city', ['TOR']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('multi2', $results[0]->getId());
@@ -1609,10 +1382,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => null, // null value
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'null2',
@@ -1621,21 +1394,21 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         // missing email key entirely
                         'info' => [
-                            'country' => 'CA'
-                        ]
-                    ]
-                ]
+                            'country' => 'CA',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'null3',
                 '$permissions' => [Permission::read(Role::any())],
-                'profile' => null // entire profile is null
-            ])
+                'profile' => null, // entire profile is null
+            ]),
         ]);
 
         // Query for null email should not match null1 (null values typically don't match equal queries)
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['non-existent@test.com'])
+            Query::equal('profile.user.email', ['non-existent@test.com']),
         ]);
         // Should not include null1, null2, or null3
         foreach ($results as $doc) {
@@ -1655,10 +1428,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'alice.mixed@test.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'mixed2',
@@ -1669,21 +1442,21 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'bob.mixed@test.com',
                         'info' => [
-                            'country' => 'CA'
-                        ]
-                    ]
-                ]
-            ])
+                            'country' => 'CA',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Create indexes on regular attributes
-        $database->createIndex($collectionId, 'idx_name', Database::INDEX_KEY, ['name']);
-        $database->createIndex($collectionId, 'idx_age', Database::INDEX_KEY, ['age']);
+        $database->createIndex($collectionId, Index::key(key: 'idx_name', attributes: ['name']));
+        $database->createIndex($collectionId, Index::key(key: 'idx_age', attributes: ['age']));
 
         // Combined query: nested path + regular attribute
         $results = $database->find($collectionId, [
             Query::equal('profile.user.info.country', ['US']),
-            Query::equal('name', ['Alice'])
+            Query::equal('name', ['Alice']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('mixed1', $results[0]->getId());
@@ -1692,8 +1465,8 @@ public function testNestedObjectAttributeEdgeCases(): void
         $results = $database->find($collectionId, [
             Query::and([
                 Query::equal('profile.user.email', ['bob.mixed@test.com']),
-                Query::equal('age', [30])
-            ])
+                Query::equal('age', [30]),
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('mixed2', $results[0]->getId());
@@ -1708,15 +1481,15 @@ public function testNestedObjectAttributeEdgeCases(): void
                 'user' => [
                     'email' => 'alice.updated@test.com', // changed email
                     'info' => [
-                        'country' => 'CA' // changed country
-                    ]
-                ]
-            ]
+                        'country' => 'CA', // changed country
+                    ],
+                ],
+            ],
         ]));
 
         // Query with old email should not match
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['alice.mixed@test.com'])
+            Query::equal('profile.user.email', ['alice.mixed@test.com']),
         ]);
         foreach ($results as $doc) {
             $this->assertNotEquals('mixed1', $doc->getId());
@@ -1724,14 +1497,14 @@ public function testNestedObjectAttributeEdgeCases(): void
 
         // Query with new email should match
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['alice.updated@test.com'])
+            Query::equal('profile.user.email', ['alice.updated@test.com']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('mixed1', $results[0]->getId());
 
         // Query with new country should match
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.info.country', ['CA'])
+            Query::equal('profile.user.info.country', ['CA']),
         ]);
         $this->assertGreaterThanOrEqual(2, count($results)); // Should include mixed1 and mixed2
 
@@ -1745,10 +1518,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'noindex1@test.com',
                         'info' => [
                             'country' => 'US',
-                            'phone' => '+1234567890' // no index on this path
-                        ]
-                    ]
-                ]
+                            'phone' => '+1234567890', // no index on this path
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'noindex2',
@@ -1758,16 +1531,16 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'noindex2@test.com',
                         'info' => [
                             'country' => 'CA',
-                            'phone' => '+9876543210' // no index on this path
-                        ]
-                    ]
-                ]
-            ])
+                            'phone' => '+9876543210', // no index on this path
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Query on non-indexed nested path should still work
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.info.phone', ['+1234567890'])
+            Query::equal('profile.user.info.phone', ['+1234567890']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('noindex1', $results[0]->getId());
@@ -1783,10 +1556,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'info' => [
                             'country' => 'US',
                             'city' => 'NYC',
-                            'zip' => '10001'
-                        ]
-                    ]
-                ]
+                            'zip' => '10001',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'complex2',
@@ -1797,10 +1570,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'info' => [
                             'country' => 'US',
                             'city' => 'LAX',
-                            'zip' => '90001'
-                        ]
-                    ]
-                ]
+                            'zip' => '90001',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'complex3',
@@ -1811,19 +1584,19 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'info' => [
                             'country' => 'CA',
                             'city' => 'TOR',
-                            'zip' => 'M5H1A1'
-                        ]
-                    ]
-                ]
-            ])
+                            'zip' => 'M5H1A1',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Complex AND with multiple nested paths
         $results = $database->find($collectionId, [
             Query::and([
                 Query::equal('profile.user.info.country', ['US']),
-                Query::equal('profile.user.info.city', ['NYC'])
-            ])
+                Query::equal('profile.user.info.city', ['NYC']),
+            ]),
         ]);
 
         $this->assertCount(2, $results);
@@ -1832,13 +1605,13 @@ public function testNestedObjectAttributeEdgeCases(): void
         $results = $database->find($collectionId, [
             Query::or([
                 Query::equal('profile.user.info.city', ['NYC']),
-                Query::equal('profile.user.info.city', ['TOR'])
-            ])
+                Query::equal('profile.user.info.city', ['TOR']),
+            ]),
         ]);
         $this->assertCount(4, $results);
         $ids = \array_map(fn (Document $d) => $d->getId(), $results);
         \sort($ids);
-        $this->assertEquals(['complex1', 'complex3','multi1','multi2'], $ids);
+        $this->assertEquals(['complex1', 'complex3', 'multi1', 'multi2'], $ids);
 
         // Complex nested AND/OR combination
         $results = $database->find($collectionId, [
@@ -1846,9 +1619,9 @@ public function testNestedObjectAttributeEdgeCases(): void
                 Query::equal('profile.user.info.country', ['US']),
                 Query::or([
                     Query::equal('profile.user.info.city', ['NYC']),
-                    Query::equal('profile.user.info.city', ['LAX'])
-                ])
-            ])
+                    Query::equal('profile.user.info.city', ['LAX']),
+                ]),
+            ]),
         ]);
         $this->assertCount(3, $results);
         $ids = \array_map(fn (Document $d) => $d->getId(), $results);
@@ -1864,10 +1637,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'a@order.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'order2',
@@ -1876,10 +1649,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'b@order.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'order3',
@@ -1888,17 +1661,17 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'c@order.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
-            ])
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Limit with nested query
         $results = $database->find($collectionId, [
             Query::equal('profile.user.info.country', ['US']),
-            Query::limit(2)
+            Query::limit(2),
         ]);
         $this->assertCount(2, $results);
 
@@ -1906,7 +1679,7 @@ public function testNestedObjectAttributeEdgeCases(): void
         $results = $database->find($collectionId, [
             Query::equal('profile.user.info.country', ['US']),
             Query::offset(1),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertCount(1, $results);
 
@@ -1919,16 +1692,16 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => '', // empty string
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
-            ])
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // Query for empty string
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', [''])
+            Query::equal('profile.user.email', ['']),
         ]);
         $this->assertGreaterThanOrEqual(1, count($results));
         $found = false;
@@ -1945,23 +1718,23 @@ public function testNestedObjectAttributeEdgeCases(): void
 
         // Query should still work without index (just slower)
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['alice.updated@test.com'])
+            Query::equal('profile.user.email', ['alice.updated@test.com']),
         ]);
         $this->assertGreaterThanOrEqual(1, count($results));
 
         // Re-create index
-        $created = $database->createIndex($collectionId, 'idx_email_recreated', Database::INDEX_KEY, ['profile.user.email']);
+        $created = $database->createIndex($collectionId, Index::key(key: 'idx_email_recreated', attributes: ['profile.user.email']));
         $this->assertTrue($created);
 
         // Query should still work with recreated index
         $results = $database->find($collectionId, [
-            Query::equal('profile.user.email', ['alice.updated@test.com'])
+            Query::equal('profile.user.email', ['alice.updated@test.com']),
         ]);
         $this->assertGreaterThanOrEqual(1, count($results));
 
         // Edge Case 11: UNIQUE index with updates (duplicate prevention)
-        if ($database->getAdapter()->getSupportForIdenticalIndexes()) {
-            $created = $database->createIndex($collectionId, 'idx_unique_email', Database::INDEX_UNIQUE, ['profile.user.email']);
+        if ($database->getAdapter()->supports(Capability::IdenticalIndexes)) {
+            $created = $database->createIndex($collectionId, Index::unique(key: 'idx_unique_email', attributes: ['profile.user.email']));
             $this->assertTrue($created);
 
             // Try to create duplicate
@@ -1973,10 +1746,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'user' => [
                             'email' => 'alice.updated@test.com', // duplicate
                             'info' => [
-                                'country' => 'XX'
-                            ]
-                        ]
-                    ]
+                                'country' => 'XX',
+                            ],
+                        ],
+                    ],
                 ]));
                 $this->fail('Expected Duplicate exception for UNIQUE index');
             } catch (Exception $e) {
@@ -1994,10 +1767,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'text1@example.org',
                         'info' => [
                             'country' => 'United States',
-                            'city' => 'New York City'
-                        ]
-                    ]
-                ]
+                            'city' => 'New York City',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'text2',
@@ -2007,23 +1780,23 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'text2@test.com',
                         'info' => [
                             'country' => 'United Kingdom',
-                            'city' => 'London'
-                        ]
-                    ]
-                ]
-            ])
+                            'city' => 'London',
+                        ],
+                    ],
+                ],
+            ]),
         ]);
 
         // startsWith on nested path
         $results = $database->find($collectionId, [
-            Query::startsWith('profile.user.email', 'text1@')
+            Query::startsWith('profile.user.email', 'text1@'),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('text1', $results[0]->getId());
 
         // contains on nested path
         $results = $database->find($collectionId, [
-            Query::contains('profile.user.info.country', ['United'])
+            Query::contains('profile.user.info.country', ['United']),
         ]);
         $this->assertGreaterThanOrEqual(2, count($results));
 
diff --git a/tests/e2e/Adapter/Scopes/OperatorTests.php b/tests/e2e/Adapter/Scopes/OperatorTests.php
index 76a6d883a2..fe37de26a5 100644
--- a/tests/e2e/Adapter/Scopes/OperatorTests.php
+++ b/tests/e2e/Adapter/Scopes/OperatorTests.php
@@ -2,6 +2,9 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -19,23 +22,22 @@ trait OperatorTests
     public function testUpdateWithOperators(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection with various attribute types
         $collectionId = 'test_operators';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 100, false, 'test');
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'name', size: 100, default: 'test'));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -112,7 +114,7 @@ public function testUpdateWithOperators(): void
         $this->assertEquals([0, 1, 99, 2, 3, 4, 5], $updated->getAttribute('numbers'));
 
         // Test insert at end
-        $numbers = $updated->getAttribute('numbers');
+        $numbers = $updated->getArray('numbers');
         $lastIndex = count($numbers);
         $updated = $database->updateDocument($collectionId, 'test_doc', new Document([
             'numbers' => Operator::arrayInsert($lastIndex, 100)
@@ -125,21 +127,20 @@ public function testUpdateWithOperators(): void
     public function testUpdateDocumentsWithOperators(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_batch_operators';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'category', Database::VAR_STRING, 50, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'category', size: 50, required: true));
 
         // Create multiple test documents
         $docs = [];
@@ -172,7 +173,7 @@ public function testUpdateDocumentsWithOperators(): void
         foreach ($updated as $doc) {
             $originalCount = (int) str_replace('doc_', '', $doc->getId()) * 10;
             $this->assertEquals($originalCount + 5, $doc->getAttribute('count'));
-            $this->assertContains('batch_updated', $doc->getAttribute('tags'));
+            $this->assertContains('batch_updated', $doc->getArray('tags'));
             $this->assertEquals('updated', $doc->getAttribute('category'));
         }
 
@@ -202,39 +203,38 @@ public function testUpdateDocumentsWithOperators(): void
     public function testUpdateDocumentsWithAllOperators(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create comprehensive test collection
         $collectionId = 'test_all_operators_bulk';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create attributes for all operator types
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 10);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 5.0);
-        $database->createAttribute($collectionId, 'multiplier', Database::VAR_FLOAT, 0, false, 2.0);
-        $database->createAttribute($collectionId, 'divisor', Database::VAR_FLOAT, 0, false, 100.0);
-        $database->createAttribute($collectionId, 'remainder', Database::VAR_INTEGER, 0, false, 20);
-        $database->createAttribute($collectionId, 'power_val', Database::VAR_FLOAT, 0, false, 2.0);
-        $database->createAttribute($collectionId, 'title', Database::VAR_STRING, 255, false, 'Title');
-        $database->createAttribute($collectionId, 'content', Database::VAR_STRING, 500, false, 'old content');
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'categories', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'duplicates', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'intersect_items', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'diff_items', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'filter_numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'active', Database::VAR_BOOLEAN, 0, false, false);
-        $database->createAttribute($collectionId, 'last_update', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
-        $database->createAttribute($collectionId, 'next_update', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
-        $database->createAttribute($collectionId, 'now_field', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 10));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 5.0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'multiplier', default: 2.0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'divisor', default: 100.0));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'remainder', default: 20));
+        $database->createAttribute($collectionId, Attribute::double(key: 'power_val', default: 2.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'title', default: 'Title'));
+        $database->createAttribute($collectionId, Attribute::string(key: 'content', size: 500, default: 'old content'));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'categories', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'duplicates', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'intersect_items', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'diff_items', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'filter_numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'active', default: false));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'last_update', filters: ['datetime']));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'next_update', filters: ['datetime']));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'now_field', filters: ['datetime']));
 
         // Create test documents
         $docs = [];
@@ -307,10 +307,10 @@ public function testUpdateDocumentsWithAllOperators(): void
         $this->assertEquals(4.0, $doc1->getAttribute('power_val'));       // 2^2
         $this->assertEquals('Title 1 - Updated', $doc1->getAttribute('title'));
         $this->assertEquals('new content 1', $doc1->getAttribute('content'));
-        $this->assertContains('bulk', $doc1->getAttribute('tags'));
-        $this->assertContains('priority', $doc1->getAttribute('categories'));
-        $this->assertNotContains('shared', $doc1->getAttribute('items'));
-        $this->assertCount(4, $doc1->getAttribute('duplicates')); // Should have unique values
+        $this->assertContains('bulk', $doc1->getArray('tags'));
+        $this->assertContains('priority', $doc1->getArray('categories'));
+        $this->assertNotContains('shared', $doc1->getArray('items'));
+        $this->assertCount(4, $doc1->getArray('duplicates')); // Should have unique values
         $this->assertEquals([1, 2, 99, 3, 4, 5], $doc1->getAttribute('numbers')); // arrayInsert at index 2
         $this->assertEquals(['b', 'c'], $doc1->getAttribute('intersect_items')); // arrayIntersect
         $this->assertEquals(['x', 'w'], $doc1->getAttribute('diff_items')); // arrayDiff (removed y, z)
@@ -352,22 +352,21 @@ public function testUpdateDocumentsWithAllOperators(): void
     public function testUpdateDocumentsOperatorsWithQueries(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_operators_with_queries';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'category', Database::VAR_STRING, 50, true);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'active', Database::VAR_BOOLEAN, 0, false, false);
+        $database->createAttribute($collectionId, Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'active', default: false));
 
         // Create test documents
         for ($i = 1; $i <= 5; $i++) {
@@ -436,17 +435,17 @@ public function testUpdateDocumentsOperatorsWithSelect(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_operators_with_select';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'category', Database::VAR_STRING, 50, true);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createAttribute($collectionId, Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
 
         for ($i = 1; $i <= 3; $i++) {
             $database->createDocument($collectionId, new Document([
@@ -498,15 +497,15 @@ public function testUpdateDocumentsOperatorsBatchLargerThanDefaultLimit(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_operators_large_batch';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
 
         // More documents than find()'s default limit (25) so the refetch must page/limit correctly.
         $total = 60;
@@ -555,7 +554,7 @@ public function testUpdateDocumentOperatorDoesNotDoubleDecodeFilters(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -565,21 +564,38 @@ public function testUpdateDocumentOperatorDoesNotDoubleDecodeFilters(): void
         $database->addFilter(
             'operator_double_decode',
             function (mixed $value) {
+                if (! \is_scalar($value) && $value !== null) {
+                    throw new \InvalidArgumentException('Operator filter input must be scalar or null');
+                }
+
                 return json_encode(['data' => base64_encode((string) $value)]);
             },
-            function (mixed $value) {
+            function (mixed $value): ?string {
                 if (is_null($value)) {
-                    return;
+                    return null;
                 }
+                if (! \is_string($value)) {
+                    throw new \InvalidArgumentException('Encoded operator filter value must be a string');
+                }
+
                 $decoded = json_decode($value, true);
-                return base64_decode($decoded['data']);
+                if (! \is_array($decoded) || ! \is_string($decoded['data'] ?? null)) {
+                    throw new \InvalidArgumentException('Encoded operator filter payload is invalid');
+                }
+
+                $plain = base64_decode($decoded['data'], true);
+                if ($plain === false) {
+                    throw new \InvalidArgumentException('Encoded operator filter payload is not valid base64');
+                }
+
+                return $plain;
             }
         );
 
         $collectionId = 'test_operator_double_decode';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'secret', Database::VAR_STRING, 128, false, filters: ['operator_double_decode']);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'secret', size: 128, filters: ['operator_double_decode']));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc1',
@@ -607,21 +623,20 @@ function (mixed $value) {
     public function testOperatorErrorHandling(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_operator_errors';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'text_field', Database::VAR_STRING, 100, true);
-        $database->createAttribute($collectionId, 'number_field', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute($collectionId, 'array_field', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::string(key: 'text_field', size: 100, required: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'number_field', required: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'array_field', size: 50, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -646,20 +661,19 @@ public function testOperatorErrorHandling(): void
     public function testOperatorArrayErrorHandling(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_array_operator_errors';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'text_field', Database::VAR_STRING, 100, true);
-        $database->createAttribute($collectionId, 'array_field', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::string(key: 'text_field', size: 100, required: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'array_field', size: 50, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -683,19 +697,18 @@ public function testOperatorArrayErrorHandling(): void
     public function testOperatorInsertErrorHandling(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_insert_operator_errors';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'array_field', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::string(key: 'array_field', size: 50, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -721,25 +734,24 @@ public function testOperatorInsertErrorHandling(): void
     public function testOperatorValidationEdgeCases(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create comprehensive test collection
         $collectionId = 'test_operator_edge_cases';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create various attribute types for testing
-        $database->createAttribute($collectionId, 'string_field', Database::VAR_STRING, 100, false, 'default');
-        $database->createAttribute($collectionId, 'int_field', Database::VAR_INTEGER, 0, false, 10);
-        $database->createAttribute($collectionId, 'float_field', Database::VAR_FLOAT, 0, false, 1.5);
-        $database->createAttribute($collectionId, 'bool_field', Database::VAR_BOOLEAN, 0, false, false);
-        $database->createAttribute($collectionId, 'array_field', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'date_field', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createAttribute($collectionId, Attribute::string(key: 'string_field', size: 100, default: 'default'));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'int_field', default: 10));
+        $database->createAttribute($collectionId, Attribute::double(key: 'float_field', default: 1.5));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'bool_field', default: false));
+        $database->createAttribute($collectionId, Attribute::string(key: 'array_field', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'date_field', filters: ['datetime']));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -810,17 +822,16 @@ public function testOperatorValidationEdgeCases(): void
     public function testOperatorDivisionModuloByZero(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_division_zero';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'number', Database::VAR_FLOAT, 0, false, 100.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'number', default: 100.0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'zero_test_doc',
@@ -866,17 +877,16 @@ public function testOperatorDivisionModuloByZero(): void
     public function testOperatorArrayInsertOutOfBounds(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_insert_bounds';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'bounds_test_doc',
@@ -912,18 +922,17 @@ public function testOperatorArrayInsertOutOfBounds(): void
     public function testOperatorValueLimits(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_operator_limits';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 10);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 5.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 10));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 5.0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'limits_test_doc',
@@ -969,18 +978,17 @@ public function testOperatorValueLimits(): void
     public function testOperatorArrayFilterValidation(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_filter';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'filter_test_doc',
@@ -1007,18 +1015,17 @@ public function testOperatorArrayFilterValidation(): void
     public function testOperatorReplaceValidation(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_replace';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false, 'default text');
-        $database->createAttribute($collectionId, 'number', Database::VAR_INTEGER, 0, false, 0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', default: 'default text'));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'number', default: 0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'replace_test_doc',
@@ -1055,19 +1062,18 @@ public function testOperatorReplaceValidation(): void
     public function testOperatorNullValueHandling(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_null_handling';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'nullable_int', Database::VAR_INTEGER, 0, false, null, false, false);
-        $database->createAttribute($collectionId, 'nullable_string', Database::VAR_STRING, 100, false, null, false, false);
-        $database->createAttribute($collectionId, 'nullable_bool', Database::VAR_BOOLEAN, 0, false, null, false, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'nullable_int', signed: false));
+        $database->createAttribute($collectionId, Attribute::string(key: 'nullable_string', size: 100, signed: false));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'nullable_bool', signed: false));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'null_test_doc',
@@ -1112,20 +1118,19 @@ public function testOperatorNullValueHandling(): void
     public function testOperatorComplexScenarios(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_complex_operators';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'stats', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'metadata', Database::VAR_STRING, 100, false, null, true, true);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 255, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'stats', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'metadata', size: 100, array: true));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'name', default: ''));
 
         // Create document with complex data
         $doc = $database->createDocument($collectionId, new Document([
@@ -1141,7 +1146,7 @@ public function testOperatorComplexScenarios(): void
         $updated = $database->updateDocument($collectionId, 'complex_test_doc', new Document([
             'stats' => Operator::arrayUnique() // Should remove duplicate 20s
         ]));
-        $stats = $updated->getAttribute('stats');
+        $stats = $updated->getArray('stats');
         $this->assertCount(4, $stats); // [10, 20, 30, 40]
         $this->assertEquals([10, 20, 30, 40], $stats);
 
@@ -1172,17 +1177,16 @@ public function testOperatorComplexScenarios(): void
     public function testOperatorIncrement(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_increment_operator';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1214,17 +1218,16 @@ public function testOperatorIncrement(): void
     public function testOperatorStringConcat(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_string_concat_operator';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'title', Database::VAR_STRING, 255, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'title', default: ''));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1256,17 +1259,16 @@ public function testOperatorStringConcat(): void
     public function testOperatorModulo(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_modulo_operator';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'number', Database::VAR_INTEGER, 0, false, 0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'number', default: 0));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1286,17 +1288,16 @@ public function testOperatorModulo(): void
     public function testOperatorToggle(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_toggle_operator';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'active', Database::VAR_BOOLEAN, 0, false, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'active', default: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1320,21 +1321,19 @@ public function testOperatorToggle(): void
         $database->deleteCollection($collectionId);
     }
 
-
     public function testOperatorArrayUnique(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_unique_operator';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1346,7 +1345,7 @@ public function testOperatorArrayUnique(): void
             'items' => Operator::arrayUnique()
         ]));
 
-        $result = $updated->getAttribute('items');
+        $result = $updated->getArray('items');
         $this->assertCount(3, $result);
         $this->assertContains('a', $result);
         $this->assertContains('b', $result);
@@ -1359,20 +1358,19 @@ public function testOperatorArrayUnique(): void
 
     public function testOperatorIncrementComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Setup collection
         $collectionId = 'operator_increment_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count'));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score'));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text'));
 
         // Success case - integer
         $doc = $database->createDocument($collectionId, new Document([
@@ -1418,17 +1416,16 @@ public function testOperatorIncrementComprehensive(): void
 
     public function testOperatorDecrementComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_decrement_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1463,17 +1460,16 @@ public function testOperatorDecrementComprehensive(): void
 
     public function testOperatorMultiplyComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_multiply_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1498,17 +1494,16 @@ public function testOperatorMultiplyComprehensive(): void
 
     public function testOperatorDivideComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_divide_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1533,17 +1528,16 @@ public function testOperatorDivideComprehensive(): void
 
     public function testOperatorModuloComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_modulo_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'number', Database::VAR_INTEGER, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'number'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1562,17 +1556,16 @@ public function testOperatorModuloComprehensive(): void
 
     public function testOperatorPowerComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_power_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'number', Database::VAR_FLOAT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'number'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1606,14 +1599,14 @@ public function testOperatorBoundedShrinkApplies(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_bounded_shrink';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', default: 0.0));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'shrink_doc',
@@ -1659,16 +1652,16 @@ public function testOperatorGuardIsPerColumn(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_guard_per_column';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 100, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'name', size: 100, default: ''));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc',
@@ -1701,15 +1694,15 @@ public function testOperatorGuardIsPerRowInBatch(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_guard_per_row';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
 
         foreach ([['d1', 10], ['d2', 48]] as [$id, $count]) {
             $database->createDocument($collectionId, new Document([
@@ -1744,14 +1737,14 @@ public function testOperatorBoundIsInclusive(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_bound_inclusive';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 0));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc',
@@ -1791,14 +1784,14 @@ public function testOperatorPowerOnZeroOrNegativeBase(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_power_edge';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', default: 0.0));
 
         // The square root of a negative number is not a real number, so -4 is left as -4.
         $database->createDocument($collectionId, new Document([
@@ -1842,14 +1835,14 @@ public function testOperatorUnboundedPowerOnUndefinedBase(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_power_undefined';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', default: 0.0));
 
         // [id, starting value, operator]. Each result is mathematically undefined.
         $undefined = [
@@ -1885,7 +1878,9 @@ public function testOperatorUnboundedPowerOnUndefinedBase(): void
                 // base) must still not store a wrong real number: the value is either untouched or
                 // an explicit "not a number" marker (NULL / NaN). Verify with a fresh read.
                 $stored = $database->getDocument($collectionId, $id)->getAttribute('value');
-                $safe = $stored === null || $stored == $start || !\is_finite((float) $stored);
+                $safe = $stored === null
+                    || $stored == $start
+                    || (\is_numeric($stored) && ! \is_finite((float) $stored));
                 $this->assertTrue($safe, "{$id}: undefined power neither raised a LimitException nor left a safe value; stored " . \var_export($stored, true));
             }
         }
@@ -1912,14 +1907,14 @@ public function testOperatorBoundedPowerComputesWithinMax(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_bounded_power';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', default: 0.0));
 
         // [id, starting value, operator, expected stored value].
         $cases = [
@@ -1959,14 +1954,14 @@ public function testOperatorArraySizeLimit(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_array_size_limit';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc',
@@ -2008,14 +2003,14 @@ public function testOperatorArrayFilterRejectsUnknownCondition(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_filter_unknown_cond';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc',
@@ -2044,14 +2039,14 @@ public function testOperatorArrayFilterAllConditions(): void
     {
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'operator_filter_all_conditions';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
         $database->createDocument($collectionId, new Document([
             '$id' => 'doc',
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2074,7 +2069,9 @@ public function testOperatorArrayFilterAllConditions(): void
             $updated = $database->updateDocument($collectionId, 'doc', new Document([
                 'numbers' => Operator::arrayFilter($condition, $compare),
             ]));
-            $this->assertEquals($expected, \array_values($updated->getAttribute('numbers')), "arrayFilter('{$condition}') gave the wrong result");
+            $numbers = $updated->getAttribute('numbers');
+            $this->assertIsArray($numbers);
+            $this->assertEquals($expected, \array_values($numbers), "arrayFilter('{$condition}') gave the wrong result");
         }
 
         $database->deleteCollection($collectionId);
@@ -2082,17 +2079,16 @@ public function testOperatorArrayFilterAllConditions(): void
 
     public function testOperatorStringConcatComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_concat_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text'));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2121,17 +2117,16 @@ public function testOperatorStringConcatComprehensive(): void
 
     public function testOperatorReplaceComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_replace_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text'));
 
         // Success case - single replacement
         $doc = $database->createDocument($collectionId, new Document([
@@ -2162,17 +2157,16 @@ public function testOperatorReplaceComprehensive(): void
 
     public function testOperatorArrayAppendComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_append_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2211,17 +2205,16 @@ public function testOperatorArrayAppendComprehensive(): void
 
     public function testOperatorArrayPrependComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_prepend_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2240,17 +2233,16 @@ public function testOperatorArrayPrependComprehensive(): void
 
     public function testOperatorArrayInsertComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_insert_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
 
         // Success case - middle insertion
         $doc = $database->createDocument($collectionId, new Document([
@@ -2272,7 +2264,7 @@ public function testOperatorArrayInsertComprehensive(): void
         $this->assertEquals([0, 1, 2, 3, 4], $updated->getAttribute('numbers'));
 
         // Success case - end insertion
-        $numbers = $updated->getAttribute('numbers');
+        $numbers = $updated->getArray('numbers');
         $updated = $database->updateDocument($collectionId, $doc->getId(), new Document([
             'numbers' => Operator::arrayInsert(count($numbers), 5)
         ]));
@@ -2284,17 +2276,16 @@ public function testOperatorArrayInsertComprehensive(): void
 
     public function testOperatorArrayRemoveComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_remove_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case - single occurrence
         $doc = $database->createDocument($collectionId, new Document([
@@ -2332,17 +2323,16 @@ public function testOperatorArrayRemoveComprehensive(): void
 
     public function testOperatorArrayUniqueComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_unique_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case - with duplicates
         $doc = $database->createDocument($collectionId, new Document([
@@ -2354,7 +2344,7 @@ public function testOperatorArrayUniqueComprehensive(): void
             'items' => Operator::arrayUnique()
         ]));
 
-        $result = $updated->getAttribute('items');
+        $result = $updated->getArray('items');
         sort($result); // Sort for consistent comparison
         $this->assertEquals(['a', 'b', 'c'], $result);
 
@@ -2375,17 +2365,16 @@ public function testOperatorArrayUniqueComprehensive(): void
 
     public function testOperatorArrayIntersectComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_intersect_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2397,7 +2386,7 @@ public function testOperatorArrayIntersectComprehensive(): void
             'items' => Operator::arrayIntersect(['b', 'c', 'e'])
         ]));
 
-        $result = $updated->getAttribute('items');
+        $result = $updated->getArray('items');
         sort($result);
         $this->assertEquals(['b', 'c'], $result);
 
@@ -2413,17 +2402,16 @@ public function testOperatorArrayIntersectComprehensive(): void
 
     public function testOperatorArrayDiffComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_diff_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2435,7 +2423,7 @@ public function testOperatorArrayDiffComprehensive(): void
             'items' => Operator::arrayDiff(['b', 'd'])
         ]));
 
-        $result = $updated->getAttribute('items');
+        $result = $updated->getArray('items');
         sort($result);
         $this->assertEquals(['a', 'c'], $result);
 
@@ -2444,7 +2432,7 @@ public function testOperatorArrayDiffComprehensive(): void
             'items' => Operator::arrayDiff([])
         ]));
 
-        $result = $updated->getAttribute('items');
+        $result = $updated->getArray('items');
         sort($result);
         $this->assertEquals(['a', 'c'], $result); // Should remain unchanged
 
@@ -2453,18 +2441,17 @@ public function testOperatorArrayDiffComprehensive(): void
 
     public function testOperatorArrayFilterComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_filter_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'mixed', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'mixed', size: 50, array: true));
 
         // Success case - equals condition
         $doc = $database->createDocument($collectionId, new Document([
@@ -2513,18 +2500,17 @@ public function testOperatorArrayFilterComprehensive(): void
 
     public function testOperatorArrayFilterNumericComparisons(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_filter_numeric_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'integers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'floats', Database::VAR_FLOAT, 0, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'integers', array: true));
+        $database->createAttribute($collectionId, Attribute::double(key: 'floats', array: true));
 
         // Create document with various numeric values
         $doc = $database->createDocument($collectionId, new Document([
@@ -2570,17 +2556,16 @@ public function testOperatorArrayFilterNumericComparisons(): void
 
     public function testOperatorToggleComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_toggle_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'active', Database::VAR_BOOLEAN, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'active'));
 
         // Success case - true to false
         $doc = $database->createDocument($collectionId, new Document([
@@ -2618,17 +2603,16 @@ public function testOperatorToggleComprehensive(): void
 
     public function testOperatorDateAddDaysComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_date_add_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'date', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'date', filters: ['datetime']));
 
         // Success case - positive days
         $doc = $database->createDocument($collectionId, new Document([
@@ -2654,17 +2638,16 @@ public function testOperatorDateAddDaysComprehensive(): void
 
     public function testOperatorDateSubDaysComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_date_sub_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'date', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'date', filters: ['datetime']));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2683,17 +2666,16 @@ public function testOperatorDateSubDaysComprehensive(): void
 
     public function testOperatorDateSetNowComprehensive(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'operator_date_now_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'timestamp', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'timestamp', filters: ['datetime']));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2706,6 +2688,7 @@ public function testOperatorDateSetNowComprehensive(): void
         ]));
 
         $result = $updated->getAttribute('timestamp');
+        $this->assertIsString($result);
         $this->assertNotEmpty($result);
 
         // Verify it's a recent timestamp (within last minute)
@@ -2717,24 +2700,22 @@ public function testOperatorDateSetNowComprehensive(): void
         $database->deleteCollection($collectionId);
     }
 
-
     public function testMixedOperators(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'mixed_operators_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 255, false);
-        $database->createAttribute($collectionId, 'active', Database::VAR_BOOLEAN, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count'));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score'));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'name'));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'active'));
 
         // Test multiple operators in one update
         $doc = $database->createDocument($collectionId, new Document([
@@ -2765,18 +2746,17 @@ public function testMixedOperators(): void
 
     public function testOperatorsBatch(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'batch_operators_test';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute($collectionId, 'category', Database::VAR_STRING, 50, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count'));
+        $database->createAttribute($collectionId, Attribute::string(key: 'category', size: 50));
 
         // Create multiple documents
         $docs = [];
@@ -2817,16 +2797,16 @@ public function testOperatorsBatch(): void
      */
     public function testArrayInsertAtBeginning(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_array_insert_beginning';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2860,16 +2840,16 @@ public function testArrayInsertAtBeginning(): void
      */
     public function testArrayInsertAtMiddle(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_array_insert_middle';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_INTEGER, 0, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'items', array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2903,16 +2883,16 @@ public function testArrayInsertAtMiddle(): void
      */
     public function testArrayInsertAtEnd(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_array_insert_end';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2922,7 +2902,7 @@ public function testArrayInsertAtEnd(): void
         $this->assertEquals(['apple', 'banana', 'cherry'], $doc->getAttribute('items'));
 
         // Attempt to insert at end (index = length)
-        $items = $doc->getAttribute('items');
+        $items = $doc->getArray('items');
         $updated = $database->updateDocument($collectionId, $doc->getId(), new Document([
             'items' => Operator::arrayInsert(count($items), 'date')
         ]));
@@ -2947,16 +2927,16 @@ public function testArrayInsertAtEnd(): void
      */
     public function testArrayInsertMultipleOperations(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_array_insert_multiple';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -3024,24 +3004,23 @@ public function testArrayInsertMultipleOperations(): void
      */
     public function testOperatorIncrementExceedsMaxValue(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_increment_max_violation';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create an integer attribute with a maximum value of 100
         // Using size=4 (signed int) with max constraint through Range validator
-        $database->createAttribute($collectionId, 'score', Database::VAR_INTEGER, 4, false, 0, false, false);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'score', size: 4, default: 0, signed: false));
 
         // Get the collection to verify attribute was created
         $collection = $database->getCollection($collectionId);
-        $attributes = $collection->getAttribute('attributes', []);
+        $attributes = $collection->attributes;
         $scoreAttr = null;
         foreach ($attributes as $attr) {
             if ($attr['$id'] === 'score') {
@@ -3087,6 +3066,7 @@ public function testOperatorIncrementExceedsMaxValue(): void
             // Refetch to get the actual computed value from the database
             $refetched = $database->getDocument($collectionId, $doc2->getId());
             $finalScore = $refetched->getAttribute('score');
+            $this->assertIsNumeric($finalScore);
 
             // Document the bug: The value should not exceed MAX_INT
             $this->assertLessThanOrEqual(
@@ -3112,19 +3092,18 @@ public function testOperatorIncrementExceedsMaxValue(): void
      */
     public function testOperatorConcatExceedsMaxLength(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_concat_length_violation';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create a string attribute with max length of 20 characters
-        $database->createAttribute($collectionId, 'title', Database::VAR_STRING, 20, false, '');
+        $database->createAttribute($collectionId, Attribute::string(key: 'title', size: 20, default: ''));
 
         // Create a document with a 15-character title (within limit)
         $doc = $database->createDocument($collectionId, new Document([
@@ -3132,8 +3111,10 @@ public function testOperatorConcatExceedsMaxLength(): void
             'title' => 'Hello World'  // 11 characters
         ]));
 
-        $this->assertEquals('Hello World', $doc->getAttribute('title'));
-        $this->assertEquals(11, strlen($doc->getAttribute('title')));
+        $title = $doc->getAttribute('title');
+        $this->assertIsString($title);
+        $this->assertEquals('Hello World', $title);
+        $this->assertEquals(11, strlen($title));
 
         // BUG EXPOSED: Concat a 15-character string to make total length 26 (exceeds max of 20)
         // This should throw a StructureException for exceeding max length,
@@ -3146,6 +3127,7 @@ public function testOperatorConcatExceedsMaxLength(): void
             // Refetch to get the actual computed value from the database
             $refetched = $database->getDocument($collectionId, $doc->getId());
             $finalTitle = $refetched->getAttribute('title');
+            $this->assertIsString($finalTitle);
             $finalLength = strlen($finalTitle);
 
             // Document the bug: The resulting string should not exceed 20 characters
@@ -3171,19 +3153,18 @@ public function testOperatorConcatExceedsMaxLength(): void
      */
     public function testOperatorMultiplyViolatesRange(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_multiply_range_violation';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create a signed integer attribute (max value = Database::MAX_INT = 2147483647)
-        $database->createAttribute($collectionId, 'quantity', Database::VAR_INTEGER, 4, false, 1, false, false);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'quantity', size: 4, default: 1, signed: false));
 
         // Create a document with quantity that when multiplied will exceed MAX_INT
         $doc = $database->createDocument($collectionId, new Document([
@@ -3204,6 +3185,7 @@ public function testOperatorMultiplyViolatesRange(): void
             // Refetch to get the actual computed value from the database
             $refetched = $database->getDocument($collectionId, $doc->getId());
             $finalQuantity = $refetched->getAttribute('quantity');
+            $this->assertIsNumeric($finalQuantity);
 
             // Document the bug: The value should not exceed MAX_INT
             $this->assertLessThanOrEqual(
@@ -3233,17 +3215,16 @@ public function testOperatorMultiplyViolatesRange(): void
     public function testOperatorMultiplyWithNegativeMultiplier(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_multiply_negative';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value'));
 
         // Test negative multiplier without max limit
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -3315,17 +3296,16 @@ public function testOperatorMultiplyWithNegativeMultiplier(): void
     public function testOperatorDivideWithNegativeDivisor(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_divide_negative';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value'));
 
         // Test negative divisor without min limit
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -3387,20 +3367,19 @@ public function testOperatorDivideWithNegativeDivisor(): void
      */
     public function testOperatorArrayAppendViolatesItemConstraints(): void
     {
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_item_type_violation';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create an array attribute for integers with max value constraint
         // Each item should be an integer within the valid range
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 4, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', size: 4, array: true));
 
         // Create a document with valid integer array
         $doc = $database->createDocument($collectionId, new Document([
@@ -3428,8 +3407,10 @@ public function testOperatorArrayAppendViolatesItemConstraints(): void
 
             // Refetch to get the actual computed value from the database
             $refetched = $database->getDocument($collectionId, $doc2->getId());
-            $finalNumbers = $refetched->getAttribute('numbers');
+            $finalNumbers = $refetched->getArray('numbers');
             $lastNumber = end($finalNumbers);
+            $this->assertNotFalse($lastNumber);
+            $this->assertIsNumeric($lastNumber);
 
             // Document the bug: Array items should not exceed MAX_INT
             $this->assertLessThanOrEqual(
@@ -3462,10 +3443,11 @@ public function testOperatorArrayAppendViolatesItemConstraints(): void
 
             // Refetch to get the actual computed value from the database
             $refetched = $database->getDocument($collectionId, $doc3->getId());
-            $finalNumbers = $refetched->getAttribute('numbers');
+            $finalNumbers = $refetched->getArray('numbers');
 
             // Document the bug: ALL array items should be validated
             foreach ($finalNumbers as $num) {
+                $this->assertIsNumeric($num);
                 $this->assertLessThanOrEqual(
                     Database::MAX_INT,
                     $num,
@@ -3494,18 +3476,17 @@ public function testOperatorArrayAppendViolatesItemConstraints(): void
     public function testOperatorWithExtremeIntegerValues(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_extreme_integers';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'bigint_max', Database::VAR_INTEGER, 8, true);
-        $database->createAttribute($collectionId, 'bigint_min', Database::VAR_INTEGER, 8, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::bigInteger(key: 'bigint_max', required: true));
+        $database->createAttribute($collectionId, Attribute::bigInteger(key: 'bigint_min', required: true));
 
         $maxValue = PHP_INT_MAX - 1000; // Near max but with room
         $minValue = PHP_INT_MIN + 1000; // Near min but with room
@@ -3543,17 +3524,16 @@ public function testOperatorWithExtremeIntegerValues(): void
     public function testOperatorPowerWithNegativeExponent(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_negative_power';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', required: true));
 
         // Create document with value 8
         $doc = $database->createDocument($collectionId, new Document([
@@ -3579,17 +3559,16 @@ public function testOperatorPowerWithNegativeExponent(): void
     public function testOperatorPowerWithFractionalExponent(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_fractional_power';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', required: true));
 
         // Create document with value 16
         $doc = $database->createDocument($collectionId, new Document([
@@ -3626,17 +3605,16 @@ public function testOperatorPowerWithFractionalExponent(): void
     public function testOperatorWithEmptyStrings(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_empty_strings';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_str_doc',
@@ -3683,17 +3661,16 @@ public function testOperatorWithEmptyStrings(): void
     public function testOperatorWithUnicodeCharacters(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_unicode';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 500, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', size: 500, default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'unicode_doc',
@@ -3721,7 +3698,9 @@ public function testOperatorWithUnicodeCharacters(): void
         $updated = $database->updateDocument($collectionId, 'unicode_doc', new Document([
             'text' => Operator::stringConcat(' ☕')
         ]));
-        $this->assertStringContainsString('☕', $updated->getAttribute('text'));
+        $unicodeText = $updated->getAttribute('text');
+        $this->assertIsString($unicodeText);
+        $this->assertStringContainsString('☕', $unicodeText);
 
         $database->deleteCollection($collectionId);
     }
@@ -3733,17 +3712,16 @@ public function testOperatorWithUnicodeCharacters(): void
     public function testOperatorArrayOperationsOnEmptyArrays(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_empty_arrays';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_array_doc',
@@ -3803,17 +3781,16 @@ public function testOperatorArrayOperationsOnEmptyArrays(): void
     public function testOperatorArrayWithNullAndSpecialValues(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_special_values';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'mixed', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'mixed', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'special_values_doc',
@@ -3825,10 +3802,10 @@ public function testOperatorArrayWithNullAndSpecialValues(): void
         $updated = $database->updateDocument($collectionId, 'special_values_doc', new Document([
             'mixed' => Operator::arrayUnique()
         ]));
-        $this->assertContains('', $updated->getAttribute('mixed'));
-        $this->assertContains('text', $updated->getAttribute('mixed'));
+        $this->assertContains('', $updated->getArray('mixed'));
+        $this->assertContains('text', $updated->getArray('mixed'));
         // Should have only 2 unique values: '' and 'text'
-        $this->assertCount(2, $updated->getAttribute('mixed'));
+        $this->assertCount(2, $updated->getArray('mixed'));
 
         // Test remove empty string
         $database->updateDocument($collectionId, 'special_values_doc', new Document([
@@ -3838,7 +3815,7 @@ public function testOperatorArrayWithNullAndSpecialValues(): void
         $updated = $database->updateDocument($collectionId, 'special_values_doc', new Document([
             'mixed' => Operator::arrayRemove('')
         ]));
-        $this->assertNotContains('', $updated->getAttribute('mixed'));
+        $this->assertNotContains('', $updated->getArray('mixed'));
         $this->assertEquals(['a', 'b'], $updated->getAttribute('mixed'));
 
         $database->deleteCollection($collectionId);
@@ -3851,17 +3828,16 @@ public function testOperatorArrayWithNullAndSpecialValues(): void
     public function testOperatorModuloWithNegativeNumbers(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_negative_modulo';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_INTEGER, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'value', required: true));
 
         // Test -17 % 5 (different languages handle this differently)
         $doc = $database->createDocument($collectionId, new Document([
@@ -3899,17 +3875,16 @@ public function testOperatorModuloWithNegativeNumbers(): void
     public function testOperatorFloatPrecisionLoss(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_float_precision';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'precision_doc',
@@ -3951,17 +3926,16 @@ public function testOperatorFloatPrecisionLoss(): void
     public function testOperatorWithVeryLongStrings(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_long_strings';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 70000, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', size: 70000, default: ''));
 
         // Create a long string (10k characters)
         $longString = str_repeat('A', 10000);
@@ -3978,6 +3952,7 @@ public function testOperatorWithVeryLongStrings(): void
         ]));
 
         $result = $updated->getAttribute('text');
+        $this->assertIsString($result);
         $this->assertEquals(20000, strlen($result));
         $this->assertStringStartsWith('AAA', $result);
         $this->assertStringEndsWith('BBB', $result);
@@ -3988,6 +3963,7 @@ public function testOperatorWithVeryLongStrings(): void
         ]));
 
         $result = $updated->getAttribute('text');
+        $this->assertIsString($result);
         $this->assertStringNotContainsString('A', $result);
         $this->assertStringContainsString('X', $result);
 
@@ -4001,17 +3977,16 @@ public function testOperatorWithVeryLongStrings(): void
     public function testOperatorDateAtYearBoundaries(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_date_boundaries';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'date', Database::VAR_DATETIME, 0, false, null, true, false, null, [], ['datetime']);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::datetime(key: 'date', filters: ['datetime']));
 
         // Test date at end of year
         $doc = $database->createDocument($collectionId, new Document([
@@ -4026,6 +4001,7 @@ public function testOperatorDateAtYearBoundaries(): void
         ]));
 
         $resultDate = $updated->getAttribute('date');
+        $this->assertIsString($resultDate);
         $this->assertStringStartsWith('2024-01-01', $resultDate);
 
         // Test leap year: Feb 28, 2024 + 1 day = Feb 29, 2024 (leap year)
@@ -4038,6 +4014,7 @@ public function testOperatorDateAtYearBoundaries(): void
         ]));
 
         $resultDate = $updated->getAttribute('date');
+        $this->assertIsString($resultDate);
         $this->assertStringStartsWith('2024-02-29', $resultDate);
 
         // Test non-leap year: Feb 28, 2023 + 1 day = Mar 1, 2023
@@ -4050,6 +4027,7 @@ public function testOperatorDateAtYearBoundaries(): void
         ]));
 
         $resultDate = $updated->getAttribute('date');
+        $this->assertIsString($resultDate);
         $this->assertStringStartsWith('2023-03-01', $resultDate);
 
         // Test large day addition (cross multiple months)
@@ -4062,6 +4040,7 @@ public function testOperatorDateAtYearBoundaries(): void
         ]));
 
         $resultDate = $updated->getAttribute('date');
+        $this->assertIsString($resultDate);
         $this->assertStringStartsWith('2024-01-01', $resultDate);
 
         $database->deleteCollection($collectionId);
@@ -4074,17 +4053,16 @@ public function testOperatorDateAtYearBoundaries(): void
     public function testOperatorArrayInsertAtExactBoundaries(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_insert_boundaries';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'boundary_insert_doc',
@@ -4118,18 +4096,17 @@ public function testOperatorArrayInsertAtExactBoundaries(): void
     public function testOperatorSequentialApplications(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_sequential_ops';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'sequential_doc',
@@ -4185,17 +4162,16 @@ public function testOperatorSequentialApplications(): void
     public function testOperatorWithZeroValues(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_zero_values';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'zero_doc',
@@ -4241,17 +4217,16 @@ public function testOperatorWithZeroValues(): void
     public function testOperatorArrayIntersectAndDiffWithEmptyResults(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_empty_results';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_result_doc',
@@ -4291,17 +4266,16 @@ public function testOperatorArrayIntersectAndDiffWithEmptyResults(): void
     public function testOperatorReplaceMultipleOccurrences(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_replace_multiple';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'text', Database::VAR_STRING, 255, false, '');
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'text', default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'replace_multi_doc',
@@ -4335,17 +4309,16 @@ public function testOperatorReplaceMultipleOccurrences(): void
     public function testOperatorIncrementDecrementWithPreciseFloats(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_precise_floats';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'precise_doc',
@@ -4379,17 +4352,16 @@ public function testOperatorIncrementDecrementWithPreciseFloats(): void
     public function testOperatorArrayWithSingleElement(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_single_element';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'single_elem_doc',
@@ -4439,17 +4411,16 @@ public function testOperatorArrayWithSingleElement(): void
     public function testOperatorToggleFromDefaultValue(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_toggle_default';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'flag', Database::VAR_BOOLEAN, 0, false, false);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::boolean(key: 'flag', default: false));
 
         // Create doc without setting flag (should use default false)
         $doc = $database->createDocument($collectionId, new Document([
@@ -4482,18 +4453,17 @@ public function testOperatorToggleFromDefaultValue(): void
     public function testOperatorWithAttributeConstraints(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_attribute_constraints';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
         // Integer with size 0 (32-bit INT)
-        $database->createAttribute($collectionId, 'small_int', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'small_int', required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'constraint_doc',
@@ -4523,21 +4493,20 @@ public function testOperatorWithAttributeConstraints(): void
     public function testBulkUpdateWithOperatorsCallbackReceivesFreshData(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_bulk_callback';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         // Create multiple test documents
         for ($i = 1; $i <= 5; $i++) {
@@ -4567,9 +4536,13 @@ function (Document $doc, Document $old) use (&$callbackResults) {
                 $this->assertIsArray($doc->getAttribute('tags'));
 
                 // Verify values are actually computed
-                $expectedCount = $old->getAttribute('count') + 7;
-                $expectedScore = $old->getAttribute('score') * 2;
-                $expectedTags = array_merge($old->getAttribute('tags'), ['updated']);
+                $oldCount = $old->getAttribute('count');
+                $oldScore = $old->getAttribute('score');
+                $this->assertIsNumeric($oldCount);
+                $this->assertIsNumeric($oldScore);
+                $expectedCount = $oldCount + 7;
+                $expectedScore = $oldScore * 2;
+                $expectedTags = array_merge($old->getArray('tags'), ['updated']);
 
                 $this->assertEquals($expectedCount, $doc->getAttribute('count'));
                 $this->assertEquals($expectedScore, $doc->getAttribute('score'));
@@ -4589,21 +4562,20 @@ function (Document $doc, Document $old) use (&$callbackResults) {
     public function testBulkUpsertWithOperatorsCallbackReceivesFreshData(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_upsert_callback';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'value', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'value', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Create existing documents
         $database->createDocument($collectionId, new Document([
@@ -4686,21 +4658,20 @@ function (Document $doc, ?Document $old) use (&$callbackResults) {
     public function testSingleUpsertWithOperators(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection
         $collectionId = 'test_single_upsert';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'count', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, Attribute::integer(key: 'count', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
 
         // Test upsert with operators on new document (insert)
         $doc = $database->upsertDocument($collectionId, new Document([
@@ -4753,25 +4724,24 @@ public function testSingleUpsertWithOperators(): void
     public function testUpsertOperatorsOnNewDocuments(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         // Create test collection with all attribute types needed for operators
         $collectionId = 'test_upsert_new_ops';
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'score', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'price', Database::VAR_FLOAT, 0, false, 0.0);
-        $database->createAttribute($collectionId, 'quantity', Database::VAR_INTEGER, 0, false, 0);
-        $database->createAttribute($collectionId, 'tags', Database::VAR_STRING, 50, false, null, true, true);
-        $database->createAttribute($collectionId, 'numbers', Database::VAR_INTEGER, 0, false, null, true, true);
-        $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 100, false, '');
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'score', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::double(key: 'price', default: 0.0));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'quantity', default: 0));
+        $database->createAttribute($collectionId, Attribute::string(key: 'tags', size: 50, array: true));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'numbers', array: true));
+        $database->createAttribute($collectionId, Attribute::string(key: 'name', size: 100, default: ''));
 
         // Test 1: INCREMENT on new document (should use 0 as default)
         $doc1 = $database->upsertDocument($collectionId, new Document([
@@ -4886,37 +4856,37 @@ public function testUpsertOperatorsOnNewDocuments(): void
     public function testUpsertDocumentsWithAllOperators(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionId = 'test_upsert_all_operators';
         $attributes = [
-            new Document(['$id' => 'counter', 'type' => Database::VAR_INTEGER, 'size' => 0, 'required' => false, 'default' => 10, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'score', 'type' => Database::VAR_FLOAT, 'size' => 0, 'required' => false, 'default' => 5.0, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'multiplier', 'type' => Database::VAR_FLOAT, 'size' => 0, 'required' => false, 'default' => 2.0, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'divisor', 'type' => Database::VAR_FLOAT, 'size' => 0, 'required' => false, 'default' => 100.0, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'remainder', 'type' => Database::VAR_INTEGER, 'size' => 0, 'required' => false, 'default' => 20, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'power_val', 'type' => Database::VAR_FLOAT, 'size' => 0, 'required' => false, 'default' => 2.0, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'title', 'type' => Database::VAR_STRING, 'size' => 255, 'required' => false, 'default' => 'Title', 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'content', 'type' => Database::VAR_STRING, 'size' => 500, 'required' => false, 'default' => 'old content', 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'tags', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'categories', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'items', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'duplicates', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'numbers', 'type' => Database::VAR_INTEGER, 'size' => 0, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'intersect_items', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'diff_items', 'type' => Database::VAR_STRING, 'size' => 50, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'filter_numbers', 'type' => Database::VAR_INTEGER, 'size' => 0, 'required' => false, 'default' => null, 'signed' => true, 'array' => true]),
-            new Document(['$id' => 'active', 'type' => Database::VAR_BOOLEAN, 'size' => 0, 'required' => false, 'default' => false, 'signed' => true, 'array' => false]),
-            new Document(['$id' => 'date_field1', 'type' => Database::VAR_DATETIME, 'size' => 0, 'required' => false, 'default' => null, 'signed' => true, 'array' => false, 'format' => '', 'filters' => ['datetime']]),
-            new Document(['$id' => 'date_field2', 'type' => Database::VAR_DATETIME, 'size' => 0, 'required' => false, 'default' => null, 'signed' => true, 'array' => false, 'format' => '', 'filters' => ['datetime']]),
-            new Document(['$id' => 'date_field3', 'type' => Database::VAR_DATETIME, 'size' => 0, 'required' => false, 'default' => null, 'signed' => true, 'array' => false, 'format' => '', 'filters' => ['datetime']]),
+            Attribute::integer(key: 'counter', default: 10),
+            Attribute::double(key: 'score', default: 5.0),
+            Attribute::double(key: 'multiplier', default: 2.0),
+            Attribute::double(key: 'divisor', default: 100.0),
+            Attribute::integer(key: 'remainder', default: 20),
+            Attribute::double(key: 'power_val', default: 2.0),
+            Attribute::string(key: 'title', default: 'Title'),
+            Attribute::string(key: 'content', size: 500, default: 'old content'),
+            Attribute::string(key: 'tags', size: 50, array: true),
+            Attribute::string(key: 'categories', size: 50, array: true),
+            Attribute::string(key: 'items', size: 50, array: true),
+            Attribute::string(key: 'duplicates', size: 50, array: true),
+            Attribute::integer(key: 'numbers', array: true),
+            Attribute::string(key: 'intersect_items', size: 50, array: true),
+            Attribute::string(key: 'diff_items', size: 50, array: true),
+            Attribute::integer(key: 'filter_numbers', array: true),
+            Attribute::boolean(key: 'active', default: false),
+            Attribute::datetime(key: 'date_field1', filters: ['datetime']),
+            Attribute::datetime(key: 'date_field2', filters: ['datetime']),
+            Attribute::datetime(key: 'date_field3', filters: ['datetime']),
         ];
-        $database->createCollection($collectionId, $attributes);
+        $database->createCollection(new Collection(id: $collectionId, attributes: $attributes));
 
         $database->createDocument($collectionId, new Document([
             '$id' => 'upsert_doc_1',
@@ -5062,10 +5032,10 @@ public function testUpsertDocumentsWithAllOperators(): void
         $this->assertEquals(4.0, $doc1->getAttribute('power_val'));       // 2^2
         $this->assertEquals('Title 1 - Updated', $doc1->getAttribute('title'));
         $this->assertEquals('new content 1', $doc1->getAttribute('content'));
-        $this->assertContains('upsert', $doc1->getAttribute('tags'));
-        $this->assertContains('priority', $doc1->getAttribute('categories'));
-        $this->assertNotContains('shared', $doc1->getAttribute('items'));
-        $this->assertCount(4, $doc1->getAttribute('duplicates')); // Should have unique values
+        $this->assertContains('upsert', $doc1->getArray('tags'));
+        $this->assertContains('priority', $doc1->getArray('categories'));
+        $this->assertNotContains('shared', $doc1->getArray('items'));
+        $this->assertCount(4, $doc1->getArray('duplicates')); // Should have unique values
         $this->assertEquals([1, 2, 99, 3, 4, 5], $doc1->getAttribute('numbers')); // arrayInsert at index 2
         $this->assertEquals(['b', 'c'], $doc1->getAttribute('intersect_items')); // arrayIntersect
         $this->assertEquals(['x', 'w'], $doc1->getAttribute('diff_items')); // arrayDiff (removed y, z)
@@ -5117,17 +5087,16 @@ public function testUpsertDocumentsWithAllOperators(): void
     public function testOperatorArrayEmptyResultsNotNull(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_array_not_null';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'items', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::string(key: 'items', size: 50, array: true));
 
         // Test ARRAY_UNIQUE on empty array returns [] not NULL
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -5179,17 +5148,16 @@ public function testOperatorArrayEmptyResultsNotNull(): void
     public function testUpdateDocumentsWithOperatorsCacheInvalidation(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForOperators()) {
+        if (!$database->getAdapter()->supports(Capability::Operators)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-
         $collectionId = 'test_operator_cache';
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'counter', Database::VAR_INTEGER, 0, false, 0);
+        $database->createCollection(new Collection(id: $collectionId));
+        $database->createAttribute($collectionId, Attribute::integer(key: 'counter', default: 0));
 
         // Create a document
         $doc = $database->createDocument($collectionId, new Document([
diff --git a/tests/e2e/Adapter/Scopes/PermissionTests.php b/tests/e2e/Adapter/Scopes/PermissionTests.php
index 97e55633fc..362101ebe0 100644
--- a/tests/e2e/Adapter/Scopes/PermissionTests.php
+++ b/tests/e2e/Adapter/Scopes/PermissionTests.php
@@ -3,7 +3,11 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
@@ -12,6 +16,9 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait PermissionTests
 {
@@ -22,8 +29,9 @@ public function testUpdatingASharedDefinitionKeepsItsPermissionRowsTenantless():
 
         // Only the SQL adapters keep permissions in a side table that carries
         // its own tenant column; Mongo stores them on the document itself.
-        if (!$database->getSharedTables() || !$database->getAdapter() instanceof SQL) {
+        if (! $database->getSharedTables() || ! $database->getAdapter() instanceof SQL) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -34,7 +42,11 @@ public function testUpdatingASharedDefinitionKeepsItsPermissionRowsTenantless():
             // A shared pool's system collections are created once with no
             // tenant, so every tenant on the pool reads the one definition.
             $database->setTenant(null);
-            $database->createCollection($collection, [], [], [Permission::read(Role::any())], false);
+            $database->createCollection(new Collection(
+                id: $collection,
+                permissions: [Permission::read(Role::any())],
+                documentSecurity: false,
+            ));
 
             // A per-project pass rewrites that definition while it holds one
             // project's tenant. The rows it writes belong to the document, not
@@ -60,19 +72,333 @@ public function testUpdatingASharedDefinitionKeepsItsPermissionRowsTenantless():
         }
     }
 
+    private static string $collSecurityCollection = '';
+
+    private static string $collSecurityParentCollection = '';
+
+    private static string $collSecurityOneToOneCollection = '';
+
+    private static string $collSecurityOneToManyCollection = '';
+
+    private static string $collUpdateCollection = '';
+
+    protected function getCollSecurityCollection(): string
+    {
+        if (self::$collSecurityCollection === '') {
+            self::$collSecurityCollection = 'collectionSecurity_' . uniqid();
+        }
+        return self::$collSecurityCollection;
+    }
+
+    protected function getCollSecurityParentCollection(): string
+    {
+        if (self::$collSecurityParentCollection === '') {
+            self::$collSecurityParentCollection = 'csParent_' . uniqid();
+        }
+        return self::$collSecurityParentCollection;
+    }
+
+    protected function getCollSecurityOneToOneCollection(): string
+    {
+        if (self::$collSecurityOneToOneCollection === '') {
+            self::$collSecurityOneToOneCollection = 'csO2O_' . uniqid();
+        }
+        return self::$collSecurityOneToOneCollection;
+    }
+
+    protected function getCollSecurityOneToManyCollection(): string
+    {
+        if (self::$collSecurityOneToManyCollection === '') {
+            self::$collSecurityOneToManyCollection = 'csO2M_' . uniqid();
+        }
+        return self::$collSecurityOneToManyCollection;
+    }
+
+    protected function getCollUpdateCollection(): string
+    {
+        if (self::$collUpdateCollection === '') {
+            self::$collUpdateCollection = 'collectionUpdate_' . uniqid();
+        }
+        return self::$collUpdateCollection;
+    }
+
+    private static bool $collPermFixtureInit = false;
+
+    /** @var array{collectionId: string, docId: string}|null */
+    private static ?array $collPermFixtureData = null;
+
+    private static bool $relPermFixtureInit = false;
+
+    /** @var array{collectionId: string, oneToOneId: string, oneToManyId: string, docId: string}|null */
+    private static ?array $relPermFixtureData = null;
+
+    private static bool $collUpdateFixtureInit = false;
+
+    /** @var array{collectionId: string}|null */
+    private static ?array $collUpdateFixtureData = null;
+
+    /**
+     * Create the $this->getCollSecurityCollection() collection with a document.
+     * Combines the setup from testCollectionPermissions + testCollectionPermissionsCreateWorks.
+     *
+     * @return array{collectionId: string, docId: string}
+     */
+    protected function initCollectionPermissionFixture(): array
+    {
+        if (self::$collPermFixtureInit && self::$collPermFixtureData !== null) {
+            /** @var Database $database */
+            $database = $this->getDatabase();
+            $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+            $doc = $database->getDocument(self::$collPermFixtureData['collectionId'], self::$collPermFixtureData['docId']);
+            if (!$doc->isEmpty()) {
+                return self::$collPermFixtureData;
+            }
+            self::$collPermFixtureInit = false;
+        }
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        try {
+            $database->deleteCollection($this->getCollSecurityCollection());
+        } catch (\Throwable) {
+        }
+
+        $collection = $database->createCollection(new Collection(id: $this->getCollSecurityCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ], documentSecurity: false));
+
+        $database->createAttribute($collection->getId(), Attribute::string(key: 'test'));
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+
+        $document = $database->createDocument($collection->getId(), new Document([
+            '$id' => \Utopia\Database\Helpers\ID::unique(),
+            '$permissions' => [
+                Permission::read(Role::user('random')),
+                Permission::update(Role::user('random')),
+                Permission::delete(Role::user('random')),
+            ],
+            'test' => 'lorem',
+        ]));
+
+        self::$collPermFixtureInit = true;
+        self::$collPermFixtureData = [
+            'collectionId' => $collection->getId(),
+            'docId' => $document->getId(),
+        ];
+
+        return self::$collPermFixtureData;
+    }
+
+    /**
+     * Create the relationship permission test collections with a document.
+     * Combines testCollectionPermissionsRelationships + testCollectionPermissionsRelationshipsCreateWorks.
+     *
+     * @return array{collectionId: string, oneToOneId: string, oneToManyId: string, docId: string}
+     */
+    protected function initRelationshipPermissionFixture(): array
+    {
+        if (self::$relPermFixtureInit && self::$relPermFixtureData !== null) {
+            /** @var Database $database */
+            $database = $this->getDatabase();
+            $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+            $doc = $database->getDocument(self::$relPermFixtureData['collectionId'], self::$relPermFixtureData['docId']);
+            if (!$doc->isEmpty()) {
+                return self::$relPermFixtureData;
+            }
+            self::$relPermFixtureInit = false;
+        }
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        foreach ([$this->getCollSecurityParentCollection(), $this->getCollSecurityOneToOneCollection(), $this->getCollSecurityOneToManyCollection()] as $col) {
+            try {
+                $database->deleteCollection($col);
+            } catch (\Throwable) {
+            }
+        }
+
+        $collection = $database->createCollection(new Collection(id: $this->getCollSecurityParentCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $database->createAttribute($collection->getId(), Attribute::string(key: 'test'));
+
+        $collectionOneToOne = $database->createCollection(new Collection(id: $this->getCollSecurityOneToOneCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $database->createAttribute($collectionOneToOne->getId(), Attribute::string(key: 'test'));
+
+        $database->createRelationship(Relationship::oneToOne(collection: $collection->getId(), relatedCollection: $collectionOneToOne->getId(), key: RelationType::OneToOne->value, onDelete: ForeignKeyAction::Cascade));
+
+        $collectionOneToMany = $database->createCollection(new Collection(id: $this->getCollSecurityOneToManyCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $database->createAttribute($collectionOneToMany->getId(), Attribute::string(key: 'test'));
+
+        $database->createRelationship(Relationship::oneToMany(collection: $collection->getId(), relatedCollection: $collectionOneToMany->getId(), key: RelationType::OneToMany->value, onDelete: ForeignKeyAction::Cascade));
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+
+        $document = $database->createDocument($collection->getId(), new Document([
+            '$id' => \Utopia\Database\Helpers\ID::unique(),
+            '$permissions' => [
+                Permission::read(Role::user('random')),
+                Permission::update(Role::user('random')),
+                Permission::delete(Role::user('random')),
+            ],
+            'test' => 'lorem',
+            RelationType::OneToOne->value => [
+                '$id' => \Utopia\Database\Helpers\ID::unique(),
+                '$permissions' => [
+                    Permission::read(Role::user('random')),
+                    Permission::update(Role::user('random')),
+                    Permission::delete(Role::user('random')),
+                ],
+                'test' => 'lorem ipsum',
+            ],
+            RelationType::OneToMany->value => [
+                [
+                    '$id' => \Utopia\Database\Helpers\ID::unique(),
+                    '$permissions' => [
+                        Permission::read(Role::user('random')),
+                        Permission::update(Role::user('random')),
+                        Permission::delete(Role::user('random')),
+                    ],
+                    'test' => 'lorem ipsum',
+                ], [
+                    '$id' => \Utopia\Database\Helpers\ID::unique(),
+                    '$permissions' => [
+                        Permission::read(Role::user('torsten')),
+                        Permission::update(Role::user('random')),
+                        Permission::delete(Role::user('random')),
+                    ],
+                    'test' => 'dolor',
+                ],
+            ],
+        ]));
+
+        self::$relPermFixtureInit = true;
+        self::$relPermFixtureData = [
+            'collectionId' => $collection->getId(),
+            'oneToOneId' => $collectionOneToOne->getId(),
+            'oneToManyId' => $collectionOneToMany->getId(),
+            'docId' => $document->getId(),
+        ];
+
+        return self::$relPermFixtureData;
+    }
+
+    /**
+     * Create the $this->getCollUpdateCollection() collection.
+     * Replicates the setup from testCollectionUpdate in CollectionTests.
+     *
+     * @return array{collectionId: string}
+     */
+    protected function initCollectionUpdateFixture(): array
+    {
+        if (self::$collUpdateFixtureInit && self::$collUpdateFixtureData !== null) {
+            return self::$collUpdateFixtureData;
+        }
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        try {
+            $database->deleteCollection($this->getCollUpdateCollection());
+        } catch (\Throwable) {
+        }
+
+        $collection = $database->createCollection(new Collection(id: $this->getCollUpdateCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ], documentSecurity: false));
+
+        $database->updateCollection($this->getCollUpdateCollection(), [], true);
+
+        self::$collUpdateFixtureInit = true;
+        self::$collUpdateFixtureData = [
+            'collectionId' => $collection->getId(),
+        ];
+
+        return self::$collUpdateFixtureData;
+    }
+
+    public function testCollectionPermissionsRelationships(): void
+    {
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $collection = $database->createCollection(new Collection(id: $this->getCollSecurityParentCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $this->assertSame($this->getCollSecurityParentCollection(), $collection->getId());
+
+        $this->assertTrue($database->createAttribute($collection->getId(), Attribute::string(key: 'test')));
+
+        $collectionOneToOne = $database->createCollection(new Collection(id: $this->getCollSecurityOneToOneCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $this->assertSame($this->getCollSecurityOneToOneCollection(), $collectionOneToOne->getId());
+
+        $this->assertTrue($database->createAttribute($collectionOneToOne->getId(), Attribute::string(key: 'test')));
+
+        $this->assertTrue($database->createRelationship(Relationship::oneToOne(collection: $collection->getId(), relatedCollection: $collectionOneToOne->getId(), key: RelationType::OneToOne->value, onDelete: ForeignKeyAction::Cascade)));
+
+        $collectionOneToMany = $database->createCollection(new Collection(id: $this->getCollSecurityOneToManyCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ]));
+
+        $this->assertSame($this->getCollSecurityOneToManyCollection(), $collectionOneToMany->getId());
+
+        $this->assertTrue($database->createAttribute($collectionOneToMany->getId(), Attribute::string(key: 'test')));
+
+        $this->assertTrue($database->createRelationship(Relationship::oneToMany(collection: $collection->getId(), relatedCollection: $collectionOneToMany->getId(), key: RelationType::OneToMany->value, onDelete: ForeignKeyAction::Cascade)));
+    }
+
     public function testUnsetPermissions(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection(__FUNCTION__);
-        $this->assertTrue($database->createAttribute(
-            collection: __FUNCTION__,
-            id: 'president',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
+        $database->createCollection(new Collection(id: __FUNCTION__));
+        $this->assertTrue($database->createAttribute(__FUNCTION__, Attribute::string(key: 'president')));
 
         $permissions = [
             Permission::read(Role::any()),
@@ -219,7 +545,7 @@ public function testCreateDocumentsEmptyPermission(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection(__FUNCTION__);
+        $database->createCollection(new Collection(id: __FUNCTION__));
 
         /**
          * Validate the decode function does not add $permissions null entry when no permissions are provided
@@ -248,15 +574,16 @@ public function testCreateDocumentsEmptyPermission(): void
         }
     }
 
-    public function testReadPermissionsFailure(): Document
+    public function testReadPermissionsFailure(): void
     {
+        $this->initDocumentsFixture();
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument('documents', new Document([
+        $document = $database->createDocument($this->getDocumentsCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::user('1')),
                 Permission::create(Role::user('1')),
@@ -281,16 +608,16 @@ public function testReadPermissionsFailure(): Document
         $this->assertEquals(true, $document->isEmpty());
 
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-
-        return $document;
     }
 
-    public function testNoChangeUpdateDocumentWithoutPermission(): Document
+    public function testNoChangeUpdateDocumentWithoutPermission(): void
     {
+        $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument('documents', new Document([
+        $document = $database->createDocument($this->getDocumentsCollection(), new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any())
@@ -307,7 +634,7 @@ public function testNoChangeUpdateDocumentWithoutPermission(): Document
         ]));
 
         $updatedDocument = $database->updateDocument(
-            'documents',
+            $this->getDocumentsCollection(),
             $document->getId(),
             $document
         );
@@ -316,7 +643,7 @@ public function testNoChangeUpdateDocumentWithoutPermission(): Document
         // It should also not throw any authorization exception without any permission because of no change.
         $this->assertEquals($updatedDocument->getUpdatedAt(), $document->getUpdatedAt());
 
-        $document = $database->createDocument('documents', new Document([
+        $document = $database->createDocument($this->getDocumentsCollection(), new Document([
             '$id' => ID::unique(),
             '$permissions' => [],
             'string' => 'text📝',
@@ -333,15 +660,13 @@ public function testNoChangeUpdateDocumentWithoutPermission(): Document
         // Should throw exception, because nothing was updated, but there was no read permission
         try {
             $database->updateDocument(
-                'documents',
+                $this->getDocumentsCollection(),
                 $document->getId(),
                 $document
             );
         } catch (Exception $e) {
             $this->assertInstanceOf(AuthorizationException::class, $e);
         }
-
-        return $document;
     }
 
     public function testUpdateDocumentsPermissions(): void
@@ -349,21 +674,16 @@ public function testUpdateDocumentsPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collection = 'testUpdateDocumentsPerms';
 
-        $database->createCollection($collection, attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'size' => 767,
-                'required' => true,
-            ])
-        ], permissions: [], documentSecurity: true);
+        $database->createCollection(new Collection(id: $collection, attributes: [
+            Attribute::string(key: 'string', size: 767, required: true)
+        ]));
 
         // Test we can bulk update permissions we have access to
         $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
@@ -468,38 +788,27 @@ public function testUpdateDocumentsPermissions(): void
         }
     }
 
-    public function testCollectionPermissions(): Document
+    public function testCollectionPermissions(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = $database->createCollection('collectionSecurity', permissions: [
+        $collection = $database->createCollection(new Collection(id: $this->getCollSecurityCollection(), permissions: [
             Permission::create(Role::users()),
             Permission::read(Role::users()),
             Permission::update(Role::users()),
             Permission::delete(Role::users())
-        ], documentSecurity: false);
+        ], documentSecurity: false));
 
-        $this->assertInstanceOf(Document::class, $collection);
+        $this->assertSame($this->getCollSecurityCollection(), $collection->getId());
 
-        $this->assertTrue($database->createAttribute(
-            collection: $collection->getId(),
-            id: 'test',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
-
-        return $collection;
+        $this->assertTrue($database->createAttribute($collection->getId(), Attribute::string(key: 'test')));
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsCreateWorks
-     */
-    public function testCollectionPermissionsCountThrowsException(array $data): void
+    public function testCollectionPermissionsCountThrowsException(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -508,21 +817,17 @@ public function testCollectionPermissionsCountThrowsException(array $data): void
         $database = $this->getDatabase();
 
         try {
-            $database->count($collection->getId());
+            $database->count($collectionId);
             $this->fail('Failed to throw exception');
         } catch (\Throwable $th) {
             $this->assertInstanceOf(AuthorizationException::class, $th);
         }
     }
 
-    /**
-     * @depends testCollectionPermissionsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsCountWorks(array $data): array
+    public function testCollectionPermissionsCountWorks(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -531,19 +836,15 @@ public function testCollectionPermissionsCountWorks(array $data): array
         $database = $this->getDatabase();
 
         $count = $database->count(
-            $collection->getId()
+            $collectionId
         );
 
         $this->assertNotEmpty($count);
-
-        return $data;
     }
-
-    /**
-     * @depends testCollectionPermissions
-     */
-    public function testCollectionPermissionsCreateThrowsException(Document $collection): void
+    public function testCollectionPermissionsCreateThrowsException(): void
     {
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
         $this->expectException(AuthorizationException::class);
@@ -551,7 +852,7 @@ public function testCollectionPermissionsCreateThrowsException(Document $collect
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createDocument($collection->getId(), new Document([
+        $database->createDocument($collectionId, new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -562,19 +863,17 @@ public function testCollectionPermissionsCreateThrowsException(Document $collect
         ]));
     }
 
-    /**
-     * @depends testCollectionPermissions
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsCreateWorks(Document $collection): array
+    public function testCollectionPermissionsCreateWorks(): void
     {
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument($collection->getId(), new Document([
+        $document = $database->createDocument($collectionId, new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::user('random')),
@@ -583,18 +882,16 @@ public function testCollectionPermissionsCreateWorks(Document $collection): arra
             ],
             'test' => 'lorem'
         ]));
-        $this->assertInstanceOf(Document::class, $document);
+        $this->assertSame('lorem', $document->getAttribute('test'));
 
-        return [$collection, $document];
+        $database->deleteDocument($collectionId, $document->getId());
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsUpdateWorks
-     */
-    public function testCollectionPermissionsDeleteThrowsException(array $data): void
+    public function testCollectionPermissionsDeleteThrowsException(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -605,18 +902,16 @@ public function testCollectionPermissionsDeleteThrowsException(array $data): voi
         $database = $this->getDatabase();
 
         $database->deleteDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         );
     }
 
-    /**
-    * @param array<Document> $data
-    * @depends testCollectionPermissionsUpdateWorks
-    */
-    public function testCollectionPermissionsDeleteWorks(array $data): void
+    public function testCollectionPermissionsDeleteWorks(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -625,8 +920,8 @@ public function testCollectionPermissionsDeleteWorks(array $data): void
         $database = $this->getDatabase();
 
         $this->assertTrue($database->deleteDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         ));
     }
 
@@ -636,18 +931,15 @@ public function testCollectionPermissionsExceptions(): void
         $database = $this->getDatabase();
 
         $this->expectException(DatabaseException::class);
-        $database->createCollection('collectionSecurity', permissions: [
+        $database->createCollection(new Collection(id: $this->getCollSecurityCollection(), permissions: [
             'i dont work'
-        ]);
+        ]));
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsCreateWorks
-     */
-    public function testCollectionPermissionsFindThrowsException(array $data): void
+    public function testCollectionPermissionsFindThrowsException(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -657,17 +949,13 @@ public function testCollectionPermissionsFindThrowsException(array $data): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->find($collection->getId());
+        $database->find($collectionId);
     }
 
-    /**
-     * @depends testCollectionPermissionsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsFindWorks(array $data): array
+    public function testCollectionPermissionsFindWorks(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -675,28 +963,24 @@ public function testCollectionPermissionsFindWorks(array $data): array
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $documents = $database->find($collection->getId());
+        $documents = $database->find($collectionId);
         $this->assertNotEmpty($documents);
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
         try {
-            $database->find($collection->getId());
+            $database->find($collectionId);
             $this->fail('Failed to throw exception');
         } catch (AuthorizationException) {
         }
-
-        return $data;
     }
 
-    /**
-     * @depends testCollectionPermissionsCreateWorks
-     * @param array<Document> $data
-     */
-    public function testCollectionPermissionsGetThrowsException(array $data): void
+    public function testCollectionPermissionsGetThrowsException(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -705,21 +989,17 @@ public function testCollectionPermissionsGetThrowsException(array $data): void
         $database = $this->getDatabase();
 
         $document = $database->getDocument(
-            $collection->getId(),
-            $document->getId(),
+            $collectionId,
+            $docId,
         );
-        $this->assertInstanceOf(Document::class, $document);
         $this->assertTrue($document->isEmpty());
     }
 
-    /**
-     * @depends testCollectionPermissionsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsGetWorks(array $data): array
+    public function testCollectionPermissionsGetWorks(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -728,100 +1008,21 @@ public function testCollectionPermissionsGetWorks(array $data): array
         $database = $this->getDatabase();
 
         $document = $database->getDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         );
-        $this->assertInstanceOf(Document::class, $document);
         $this->assertFalse($document->isEmpty());
-
-        return $data;
     }
 
-    /**
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsRelationships(): array
+    public function testCollectionPermissionsRelationshipsCountWorks(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $collection = $database->createCollection('collectionSecurity.Parent', permissions: [
-            Permission::create(Role::users()),
-            Permission::read(Role::users()),
-            Permission::update(Role::users()),
-            Permission::delete(Role::users())
-        ], documentSecurity: true);
-
-        $this->assertInstanceOf(Document::class, $collection);
-
-        $this->assertTrue($database->createAttribute(
-            collection: $collection->getId(),
-            id: 'test',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
-
-        $collectionOneToOne = $database->createCollection('collectionSecurity.OneToOne', permissions: [
-            Permission::create(Role::users()),
-            Permission::read(Role::users()),
-            Permission::update(Role::users()),
-            Permission::delete(Role::users())
-        ], documentSecurity: true);
-
-        $this->assertInstanceOf(Document::class, $collectionOneToOne);
-
-        $this->assertTrue($database->createAttribute(
-            collection: $collectionOneToOne->getId(),
-            id: 'test',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
-
-        $this->assertTrue($database->createRelationship(
-            collection: $collection->getId(),
-            relatedCollection: $collectionOneToOne->getId(),
-            type: Database::RELATION_ONE_TO_ONE,
-            id: Database::RELATION_ONE_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_CASCADE
-        ));
-
-        $collectionOneToMany = $database->createCollection('collectionSecurity.OneToMany', permissions: [
-            Permission::create(Role::users()),
-            Permission::read(Role::users()),
-            Permission::update(Role::users()),
-            Permission::delete(Role::users())
-        ], documentSecurity: true);
-
-        $this->assertInstanceOf(Document::class, $collectionOneToMany);
-
-        $this->assertTrue($database->createAttribute(
-            collection: $collectionOneToMany->getId(),
-            id: 'test',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
-
-        $this->assertTrue($database->createRelationship(
-            collection: $collection->getId(),
-            relatedCollection: $collectionOneToMany->getId(),
-            type: Database::RELATION_ONE_TO_MANY,
-            id: Database::RELATION_ONE_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_CASCADE
-        ));
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        return [$collection, $collectionOneToOne, $collectionOneToMany];
-    }
-
-    /**
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     * @param array<Document> $data
-     */
-    public function testCollectionPermissionsRelationshipsCountWorks(array $data): void
-    {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -830,7 +1031,7 @@ public function testCollectionPermissionsRelationshipsCountWorks(array $data): v
         $database = $this->getDatabase();
 
         $documents = $database->count(
-            $collection->getId()
+            $collectionId
         );
 
         $this->assertEquals(1, $documents);
@@ -839,7 +1040,7 @@ public function testCollectionPermissionsRelationshipsCountWorks(array $data): v
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
         $documents = $database->count(
-            $collection->getId()
+            $collectionId
         );
 
         $this->assertEquals(1, $documents);
@@ -848,19 +1049,21 @@ public function testCollectionPermissionsRelationshipsCountWorks(array $data): v
         $this->getDatabase()->getAuthorization()->addRole(Role::user('unknown')->toString());
 
         $documents = $database->count(
-            $collection->getId()
+            $collectionId
         );
 
         $this->assertEquals(0, $documents);
     }
 
-    /**
-     * @depends testCollectionPermissionsRelationships
-     * @param array<Document> $data
-     */
-    public function testCollectionPermissionsRelationshipsCreateThrowsException(array $data): void
+    public function testCollectionPermissionsRelationshipsCreateThrowsException(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -869,7 +1072,7 @@ public function testCollectionPermissionsRelationshipsCreateThrowsException(arra
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createDocument($collection->getId(), new Document([
+        $database->createDocument($collectionId, new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -879,13 +1082,16 @@ public function testCollectionPermissionsRelationshipsCreateThrowsException(arra
         ]));
     }
 
-    /**
-    * @param array<Document> $data
-    * @depends testCollectionPermissionsRelationshipsUpdateWorks
-    */
-    public function testCollectionPermissionsRelationshipsDeleteThrowsException(array $data): void
+    public function testCollectionPermissionsRelationshipsDeleteThrowsException(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -895,27 +1101,29 @@ public function testCollectionPermissionsRelationshipsDeleteThrowsException(arra
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->deleteDocument(
-            $collection->getId(),
-            $document->getId()
+        $database->deleteDocument(
+            $collectionId,
+            $docId
         );
     }
 
-    /**
-     * @depends testCollectionPermissionsRelationships
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsRelationshipsCreateWorks(array $data): array
+    public function testCollectionPermissionsRelationshipsCreateWorks(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->createDocument($collection->getId(), new Document([
+        $document = $database->createDocument($collectionId, new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::user('random')),
@@ -923,7 +1131,7 @@ public function testCollectionPermissionsRelationshipsCreateWorks(array $data):
                 Permission::delete(Role::user('random'))
             ],
             'test' => 'lorem',
-            Database::RELATION_ONE_TO_ONE => [
+            RelationType::OneToOne->value => [
                 '$id' => ID::unique(),
                 '$permissions' => [
                     Permission::read(Role::user('random')),
@@ -932,7 +1140,7 @@ public function testCollectionPermissionsRelationshipsCreateWorks(array $data):
                 ],
                 'test' => 'lorem ipsum'
             ],
-            Database::RELATION_ONE_TO_MANY => [
+            RelationType::OneToMany->value => [
                 [
                     '$id' => ID::unique(),
                     '$permissions' => [
@@ -952,18 +1160,21 @@ public function testCollectionPermissionsRelationshipsCreateWorks(array $data):
                 ]
             ],
         ]));
-        $this->assertInstanceOf(Document::class, $document);
+        $this->assertFalse($document->isEmpty());
 
-        return [...$data, $document];
+        $database->deleteDocument($collectionId, $document->getId());
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsRelationshipsUpdateWorks
-     */
-    public function testCollectionPermissionsRelationshipsDeleteWorks(array $data): void
+    public function testCollectionPermissionsRelationshipsDeleteWorks(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -972,18 +1183,20 @@ public function testCollectionPermissionsRelationshipsDeleteWorks(array $data):
         $database = $this->getDatabase();
 
         $this->assertTrue($database->deleteDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         ));
     }
 
-    /**
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     * @param array<Document> $data
-     */
-    public function testCollectionPermissionsRelationshipsFindWorks(array $data): void
+    public function testCollectionPermissionsRelationshipsFindWorks(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -991,58 +1204,49 @@ public function testCollectionPermissionsRelationshipsFindWorks(array $data): vo
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
         $documents = $database->find(
-            $collection->getId()
+            $collectionId
         );
 
-        $this->assertIsArray($documents);
         $this->assertCount(1, $documents);
         $document = $documents[0];
-        $this->assertInstanceOf(Document::class, $document);
-        $this->assertInstanceOf(Document::class, $document->getAttribute(Database::RELATION_ONE_TO_ONE));
-        $this->assertIsArray($document->getAttribute(Database::RELATION_ONE_TO_MANY));
-        $this->assertCount(2, $document->getAttribute(Database::RELATION_ONE_TO_MANY));
+        $this->assertFalse($document->getDocument(RelationType::OneToOne->value)->isEmpty());
+        $this->assertCount(2, $document->getDocuments(RelationType::OneToMany->value));
         $this->assertFalse($document->isEmpty());
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
         $documents = $database->find(
-            $collection->getId()
+            $collectionId
         );
 
-        $this->assertIsArray($documents);
         $this->assertCount(1, $documents);
         $document = $documents[0];
-        $this->assertInstanceOf(Document::class, $document);
-        $this->assertInstanceOf(Document::class, $document->getAttribute(Database::RELATION_ONE_TO_ONE));
-        $this->assertIsArray($document->getAttribute(Database::RELATION_ONE_TO_MANY));
-        $this->assertCount(1, $document->getAttribute(Database::RELATION_ONE_TO_MANY));
+        $this->assertFalse($document->getDocument(RelationType::OneToOne->value)->isEmpty());
+        $this->assertCount(1, $document->getDocuments(RelationType::OneToMany->value));
         $this->assertFalse($document->isEmpty());
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('unknown')->toString());
 
         $documents = $database->find(
-            $collection->getId()
+            $collectionId
         );
 
-        $this->assertIsArray($documents);
         $this->assertCount(0, $documents);
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     */
-    public function testCollectionPermissionsRelationshipsGetThrowsException(array $data): void
+    public function testCollectionPermissionsRelationshipsGetThrowsException(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -1051,21 +1255,22 @@ public function testCollectionPermissionsRelationshipsGetThrowsException(array $
         $database = $this->getDatabase();
 
         $document = $database->getDocument(
-            $collection->getId(),
-            $document->getId(),
+            $collectionId,
+            $docId,
         );
-        $this->assertInstanceOf(Document::class, $document);
         $this->assertTrue($document->isEmpty());
     }
 
-    /**
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsRelationshipsGetWorks(array $data): array
+    public function testCollectionPermissionsRelationshipsGetWorks(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -1073,70 +1278,69 @@ public function testCollectionPermissionsRelationshipsGetWorks(array $data): arr
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return [];
-        }
-
         $document = $database->getDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         );
 
-        $this->assertInstanceOf(Document::class, $document);
-        $this->assertInstanceOf(Document::class, $document->getAttribute(Database::RELATION_ONE_TO_ONE));
-        $this->assertIsArray($document->getAttribute(Database::RELATION_ONE_TO_MANY));
-        $this->assertCount(2, $document->getAttribute(Database::RELATION_ONE_TO_MANY));
+        $this->assertFalse($document->getDocument(RelationType::OneToOne->value)->isEmpty());
+        $this->assertCount(2, $document->getDocuments(RelationType::OneToMany->value));
         $this->assertFalse($document->isEmpty());
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
         $document = $database->getDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         );
 
-        $this->assertInstanceOf(Document::class, $document);
-        $this->assertInstanceOf(Document::class, $document->getAttribute(Database::RELATION_ONE_TO_ONE));
-        $this->assertIsArray($document->getAttribute(Database::RELATION_ONE_TO_MANY));
-        $this->assertCount(1, $document->getAttribute(Database::RELATION_ONE_TO_MANY));
+        $this->assertFalse($document->getDocument(RelationType::OneToOne->value)->isEmpty());
+        $this->assertCount(1, $document->getDocuments(RelationType::OneToMany->value));
         $this->assertFalse($document->isEmpty());
-
-        return $data;
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     */
-    public function testCollectionPermissionsRelationshipsUpdateThrowsException(array $data): void
+    public function testCollectionPermissionsRelationshipsUpdateThrowsException(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
-
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $this->expectException(AuthorizationException::class);
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document = $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
-            $document->setAttribute('test', $document->getAttribute('test').'new_value')
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+        $document = $database->getDocument($collectionId, $docId);
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+
+        $test = $document->getAttribute('test');
+        $this->assertIsString($test);
+        $this->expectException(AuthorizationException::class);
+        $database->updateDocument(
+            $collectionId,
+            $docId,
+            $document->setAttribute('test', $test.'new_value')
         );
     }
 
-    /**
-     * @depends testCollectionPermissionsRelationshipsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsRelationshipsUpdateWorks(array $data): array
+    public function testCollectionPermissionsRelationshipsUpdateWorks(): void
     {
-        [$collection, $collectionOneToOne, $collectionOneToMany, $document] = $data;
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -1144,58 +1348,55 @@ public function testCollectionPermissionsRelationshipsUpdateWorks(array $data):
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
+        $document = $database->getDocument($collectionId, $docId);
+
+        $updated = $database->updateDocument(
+            $collectionId,
+            $docId,
             $document
         );
-
-        $this->assertTrue(true);
+        $this->assertFalse($updated->isEmpty());
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
-        $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
+        $updated = $database->updateDocument(
+            $collectionId,
+            $docId,
             $document->setAttribute('test', 'ipsum')
         );
-
-        $this->assertTrue(true);
-
-        return $data;
+        $this->assertSame('ipsum', $updated->getAttribute('test'));
     }
 
-    /**
-     * @param array<Document> $data
-     * @depends testCollectionPermissionsCreateWorks
-     */
-    public function testCollectionPermissionsUpdateThrowsException(array $data): void
+    public function testCollectionPermissionsUpdateThrowsException(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
+        $document = $database->getDocument($collectionId, $docId);
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
         $this->expectException(AuthorizationException::class);
 
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $document = $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
-            $document->setAttribute('test', 'lorem')
+        $database->updateDocument(
+            $collectionId,
+            $docId,
+            $document->setAttribute('test', 'changed_value')
         );
     }
 
-    /**
-     * @depends testCollectionPermissionsCreateWorks
-     * @param array<Document> $data
-     * @return array<Document>
-     */
-    public function testCollectionPermissionsUpdateWorks(array $data): array
+    public function testCollectionPermissionsUpdateWorks(): void
     {
-        [$collection, $document] = $data;
+        $data = $this->initCollectionPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -1203,26 +1404,25 @@ public function testCollectionPermissionsUpdateWorks(array $data): array
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->assertInstanceOf(Document::class, $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
-            $document->setAttribute('test', 'ipsum')
-        ));
+        $document = $database->getDocument($collectionId, $docId);
 
-        return $data;
+        $updated = $database->updateDocument(
+            $collectionId,
+            $docId,
+            $document->setAttribute('test', 'ipsum')
+        );
+        $this->assertSame('ipsum', $updated->getAttribute('test'));
     }
-
-    /**
-     * @depends testCollectionUpdate
-     */
-    public function testCollectionUpdatePermissionsThrowException(Document $collection): void
+    public function testCollectionUpdatePermissionsThrowException(): void
     {
+        $data = $this->initCollectionUpdateFixture();
+        $collectionId = $data['collectionId'];
         $this->expectException(DatabaseException::class);
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->updateCollection($collection->getId(), permissions: [
+        $database->updateCollection($collectionId, permissions: [
             'i dont work'
         ], documentSecurity: false);
     }
@@ -1232,11 +1432,11 @@ public function testWritePermissions(): void
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
         $database = $this->getDatabase();
 
-        $database->createCollection('animals', permissions: [
+        $database->createCollection(new Collection(id: 'animals', permissions: [
             Permission::create(Role::any()),
-        ], documentSecurity: true);
+        ]));
 
-        $database->createAttribute('animals', 'type', Database::VAR_STRING, 128, true);
+        $database->createAttribute('animals', Attribute::string(key: 'type', size: 128, required: true));
 
         $dog = $database->createDocument('animals', new Document([
             '$id' => 'dog',
@@ -1306,7 +1506,7 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (!($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -1314,25 +1514,20 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::user('a')->toString());
 
-        $database->createCollection('parentRelationTest', [], [], [
+        $database->createCollection(new Collection(id: 'parentRelationTest', permissions: [
             Permission::read(Role::user('a')),
             Permission::create(Role::user('a')),
             Permission::update(Role::user('a')),
             Permission::delete(Role::user('a'))
-        ]);
-        $database->createCollection('childRelationTest', [], [], [
+        ]));
+        $database->createCollection(new Collection(id: 'childRelationTest', permissions: [
             Permission::create(Role::user('a')),
             Permission::read(Role::user('a')),
-        ]);
-        $database->createAttribute('parentRelationTest', 'name', Database::VAR_STRING, 255, false);
-        $database->createAttribute('childRelationTest', 'name', Database::VAR_STRING, 255, false);
-
-        $database->createRelationship(
-            collection: 'parentRelationTest',
-            relatedCollection: 'childRelationTest',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'children'
-        );
+        ]));
+        $database->createAttribute('parentRelationTest', Attribute::string(key: 'name'));
+        $database->createAttribute('childRelationTest', Attribute::string(key: 'name'));
+
+        $database->createRelationship(Relationship::oneToMany(collection: 'parentRelationTest', relatedCollection: 'childRelationTest', key: 'children'));
 
         // Create document with relationship with nested data
         $parent = $database->createDocument('parentRelationTest', new Document([
@@ -1345,7 +1540,9 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
                 ],
             ],
         ]));
-        $this->assertEquals('child1', $parent->getAttribute('children')[0]->getId());
+        $children = $parent->getDocuments('children');
+        $this->assertNotEmpty($children);
+        $this->assertEquals('child1', $children[0]->getId());
         $parent->setAttribute('children', [
             [
                 '$id' => 'child2',
@@ -1353,7 +1550,9 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
         ]);
         $updatedParent = $database->updateDocument('parentRelationTest', 'parent1', $parent);
 
-        $this->assertEquals('child2', $updatedParent->getAttribute('children')[0]->getId());
+        $updatedChildren = $updatedParent->getDocuments('children');
+        $this->assertNotEmpty($updatedChildren);
+        $this->assertEquals('child2', $updatedChildren[0]->getId());
 
         $database->deleteCollection('parentRelationTest');
         $database->deleteCollection('childRelationTest');
@@ -1364,12 +1563,12 @@ public function testDocumentPermissionRolesAreMatchedExactly(): void
         /** @var Database $database */
         $database = $this->getDatabase();
         $authorization = $database->getAuthorization();
-        $collection = 'perm_exact_' . uniqid();
+        $collection = 'perm_exact_'.uniqid();
 
-        $database->createCollection($collection, permissions: [
+        $database->createCollection(new Collection(id: $collection, permissions: [
             Permission::create(Role::any()),
-        ], documentSecurity: true);
-        $database->createAttribute($collection, 'amount', Database::VAR_INTEGER, 0, true);
+        ]));
+        $database->createAttribute($collection, Attribute::integer(key: 'amount', required: true));
 
         $authorization->skip(function () use ($database, $collection): void {
             $database->createDocument($collection, new Document([
@@ -1404,7 +1603,7 @@ public function testDocumentPermissionRolesAreMatchedExactly(): void
         $this->assertSame('literal', $database->getDocument($collection, 'literal')->getId());
 
         $authorization->cleanRoles();
-        $authorization->addRole(Role::user('a' . \str_repeat('.', 19))->toString());
+        $authorization->addRole(Role::user('a'.\str_repeat('.', 19))->toString());
 
         $this->assertSame([], $this->documentIds($database->find($collection)));
         $this->assertSame(0, $database->count($collection));
@@ -1433,5 +1632,4 @@ private function documentIds(array $documents): array
             $documents,
         ));
     }
-
 }
diff --git a/tests/e2e/Adapter/Scopes/RelationshipTests.php b/tests/e2e/Adapter/Scopes/RelationshipTests.php
index 9182b8b8bd..a9b74fce26 100644
--- a/tests/e2e/Adapter/Scopes/RelationshipTests.php
+++ b/tests/e2e/Adapter/Scopes/RelationshipTests.php
@@ -7,92 +7,91 @@
 use Tests\E2E\Adapter\Scopes\Relationships\ManyToOneTests;
 use Tests\E2E\Adapter\Scopes\Relationships\OneToManyTests;
 use Tests\E2E\Adapter\Scopes\Relationships\OneToOneTests;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
-use Utopia\Database\Exception\Authorization as AuthorizationException;
-use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Relationship as RelationshipException;
-use Utopia\Database\Exception\Structure as StructureException;
-use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait RelationshipTests
 {
-    use OneToOneTests;
-    use OneToManyTests;
-    use ManyToOneTests;
     use ManyToManyTests;
+    use ManyToOneTests;
+    use OneToManyTests;
+    use OneToOneTests;
 
     public function testZoo(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('zoo');
-        $database->createAttribute('zoo', 'name', Database::VAR_STRING, 256, true);
+        $database->createCollection(new Collection(id: 'zoo'));
+        $database->createAttribute('zoo', Attribute::string(key: 'name', size: 256, required: true));
 
-        $database->createCollection('veterinarians');
-        $database->createAttribute('veterinarians', 'fullname', Database::VAR_STRING, 256, true);
+        $database->createCollection(new Collection(id: 'veterinarians'));
+        $database->createAttribute('veterinarians', Attribute::string(key: 'fullname', size: 256, required: true));
 
-        $database->createCollection('presidents');
-        $database->createAttribute('presidents', 'firstName', Database::VAR_STRING, 256, true);
-        $database->createAttribute('presidents', 'lastName', Database::VAR_STRING, 256, true);
-        $database->createRelationship(
+        $database->createCollection(new Collection(id: 'presidents'));
+        $database->createAttribute('presidents', Attribute::string(key: 'firstName', size: 256, required: true));
+        $database->createAttribute('presidents', Attribute::string(key: 'lastName', size: 256, required: true));
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'presidents',
             relatedCollection: 'veterinarians',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'votes',
+            key: 'votes',
             twoWayKey: 'presidents'
-        );
-
-        $database->createCollection('__animals');
-        $database->createAttribute('__animals', 'name', Database::VAR_STRING, 256, true);
-        $database->createAttribute('__animals', 'age', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute('__animals', 'price', Database::VAR_FLOAT, 0, false);
-        $database->createAttribute('__animals', 'dateOfBirth', Database::VAR_DATETIME, 0, true, filters:['datetime']);
-        $database->createAttribute('__animals', 'longtext', Database::VAR_STRING, 100000000, false);
-        $database->createAttribute('__animals', 'isActive', Database::VAR_BOOLEAN, 0, false, default: true);
-        $database->createAttribute('__animals', 'integers', Database::VAR_INTEGER, 0, false, array: true);
-        $database->createAttribute('__animals', 'email', Database::VAR_STRING, 255, false);
-        $database->createAttribute('__animals', 'ip', Database::VAR_STRING, 255, false);
-        $database->createAttribute('__animals', 'url', Database::VAR_STRING, 255, false);
-        $database->createAttribute('__animals', 'enum', Database::VAR_STRING, 255, false);
-
-        $database->createRelationship(
+        ));
+
+        $database->createCollection(new Collection(id: '__animals'));
+        $database->createAttribute('__animals', Attribute::string(key: 'name', size: 256, required: true));
+        $database->createAttribute('__animals', Attribute::integer(key: 'age'));
+        $database->createAttribute('__animals', Attribute::double(key: 'price'));
+        $database->createAttribute('__animals', Attribute::datetime(key: 'dateOfBirth', required: true, filters: ['datetime']));
+        $database->createAttribute('__animals', Attribute::string(key: 'longtext', size: 100000000));
+        $database->createAttribute('__animals', Attribute::boolean(key: 'isActive', default: true));
+        $database->createAttribute('__animals', Attribute::integer(key: 'integers', array: true));
+        $database->createAttribute('__animals', Attribute::string(key: 'email'));
+        $database->createAttribute('__animals', Attribute::string(key: 'ip'));
+        $database->createAttribute('__animals', Attribute::string(key: 'url'));
+        $database->createAttribute('__animals', Attribute::string(key: 'enum'));
+
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'presidents',
             relatedCollection: '__animals',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'animal',
+            key: 'animal',
             twoWayKey: 'president'
-        );
+        ));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'veterinarians',
             relatedCollection: '__animals',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'animals',
+            key: 'animals',
             twoWayKey: 'veterinarian'
-        );
+        ));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: '__animals',
             relatedCollection: 'zoo',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'zoo',
+            key: 'zoo',
             twoWayKey: 'animals'
-        );
+        ));
 
         $zoo = $database->createDocument('zoo', new Document([
             '$id' => 'zoo1',
@@ -100,7 +99,7 @@ public function testZoo(): void
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
             ],
-            'name' => 'Bronx Zoo'
+            'name' => 'Bronx Zoo',
         ]));
 
         $this->assertEquals('zoo1', $zoo->getId());
@@ -229,18 +228,18 @@ public function testZoo(): void
         $this->assertEquals('zoo1', $zoo->getId());
         $this->assertEquals('Bronx Zoo', $zoo->getAttribute('name'));
         $this->assertArrayHasKey('animals', $zoo);
-        $this->assertEquals(2, count($zoo->getAttribute('animals')));
-        $this->assertArrayHasKey('president', $zoo->getAttribute('animals')[0]);
-        $this->assertArrayHasKey('veterinarian', $zoo->getAttribute('animals')[0]);
+        $this->assertCount(2, $zoo->getDocuments('animals'));
+        $this->assertArrayHasKey('president', $zoo->getDocuments('animals')[0]);
+        $this->assertArrayHasKey('veterinarian', $zoo->getDocuments('animals')[0]);
 
         $zoo = $database->findOne('zoo');
 
         $this->assertEquals('zoo1', $zoo->getId());
         $this->assertEquals('Bronx Zoo', $zoo->getAttribute('name'));
         $this->assertArrayHasKey('animals', $zoo);
-        $this->assertEquals(2, count($zoo->getAttribute('animals')));
-        $this->assertArrayHasKey('president', $zoo->getAttribute('animals')[0]);
-        $this->assertArrayHasKey('veterinarian', $zoo->getAttribute('animals')[0]);
+        $this->assertCount(2, $zoo->getDocuments('animals'));
+        $this->assertArrayHasKey('president', $zoo->getDocuments('animals')[0]);
+        $this->assertArrayHasKey('veterinarian', $zoo->getDocuments('animals')[0]);
 
         /**
          * Check Veterinarians data
@@ -249,25 +248,25 @@ public function testZoo(): void
 
         $this->assertEquals('dr.pol', $veterinarian->getId());
         $this->assertArrayHasKey('presidents', $veterinarian);
-        $this->assertEquals(1, count($veterinarian->getAttribute('presidents')));
-        $this->assertArrayHasKey('animal', $veterinarian->getAttribute('presidents')[0]);
+        $this->assertCount(1, $veterinarian->getDocuments('presidents'));
+        $this->assertArrayHasKey('animal', $veterinarian->getDocuments('presidents')[0]);
         $this->assertArrayHasKey('animals', $veterinarian);
-        $this->assertEquals(1, count($veterinarian->getAttribute('animals')));
-        $this->assertArrayHasKey('zoo', $veterinarian->getAttribute('animals')[0]);
-        $this->assertArrayHasKey('president', $veterinarian->getAttribute('animals')[0]);
+        $this->assertCount(1, $veterinarian->getDocuments('animals'));
+        $this->assertArrayHasKey('zoo', $veterinarian->getDocuments('animals')[0]);
+        $this->assertArrayHasKey('president', $veterinarian->getDocuments('animals')[0]);
 
         $veterinarian = $database->findOne('veterinarians', [
-            Query::equal('$id', ['dr.pol'])
+            Query::equal('$id', ['dr.pol']),
         ]);
 
         $this->assertEquals('dr.pol', $veterinarian->getId());
         $this->assertArrayHasKey('presidents', $veterinarian);
-        $this->assertEquals(1, count($veterinarian->getAttribute('presidents')));
-        $this->assertArrayHasKey('animal', $veterinarian->getAttribute('presidents')[0]);
+        $this->assertCount(1, $veterinarian->getDocuments('presidents'));
+        $this->assertArrayHasKey('animal', $veterinarian->getDocuments('presidents')[0]);
         $this->assertArrayHasKey('animals', $veterinarian);
-        $this->assertEquals(1, count($veterinarian->getAttribute('animals')));
-        $this->assertArrayHasKey('zoo', $veterinarian->getAttribute('animals')[0]);
-        $this->assertArrayHasKey('president', $veterinarian->getAttribute('animals')[0]);
+        $this->assertCount(1, $veterinarian->getDocuments('animals'));
+        $this->assertArrayHasKey('zoo', $veterinarian->getDocuments('animals')[0]);
+        $this->assertArrayHasKey('president', $veterinarian->getDocuments('animals')[0]);
 
         /**
          * Check Animals data
@@ -276,25 +275,25 @@ public function testZoo(): void
 
         $this->assertEquals('iguana', $animal->getId());
         $this->assertArrayHasKey('zoo', $animal);
-        $this->assertEquals('Bronx Zoo', $animal['zoo']->getAttribute('name'));
+        $this->assertEquals('Bronx Zoo', $animal->getDocument('zoo')->getAttribute('name'));
         $this->assertArrayHasKey('veterinarian', $animal);
-        $this->assertEquals('dr.pol', $animal['veterinarian']->getId());
-        $this->assertArrayHasKey('presidents', $animal['veterinarian']);
+        $this->assertEquals('dr.pol', $animal->getDocument('veterinarian')->getId());
+        $this->assertArrayHasKey('presidents', $animal->getDocument('veterinarian'));
         $this->assertArrayHasKey('president', $animal);
-        $this->assertEquals('bush', $animal['president']->getId());
+        $this->assertEquals('bush', $animal->getDocument('president')->getId());
 
         $animal = $database->findOne('__animals', [
-            Query::equal('$id', ['tiger'])
+            Query::equal('$id', ['tiger']),
         ]);
 
         $this->assertEquals('tiger', $animal->getId());
         $this->assertArrayHasKey('zoo', $animal);
-        $this->assertEquals('Bronx Zoo', $animal['zoo']->getAttribute('name'));
+        $this->assertEquals('Bronx Zoo', $animal->getDocument('zoo')->getAttribute('name'));
         $this->assertArrayHasKey('veterinarian', $animal);
-        $this->assertEquals('dr.seuss', $animal['veterinarian']->getId());
-        $this->assertArrayHasKey('presidents', $animal['veterinarian']);
+        $this->assertEquals('dr.seuss', $animal->getDocument('veterinarian')->getId());
+        $this->assertArrayHasKey('presidents', $animal->getDocument('veterinarian'));
         $this->assertArrayHasKey('president', $animal);
-        $this->assertEquals('biden', $animal['president']->getId());
+        $this->assertEquals('biden', $animal->getDocument('president')->getId());
 
         /**
          * Check President data
@@ -304,32 +303,32 @@ public function testZoo(): void
         $this->assertEquals('trump', $president->getId());
         $this->assertArrayHasKey('animal', $president);
         $this->assertArrayHasKey('votes', $president);
-        $this->assertEquals(2, count($president['votes']));
+        $this->assertCount(2, $president->getDocuments('votes'));
 
         /**
          * Check President data
          */
         $president = $database->findOne('presidents', [
-            Query::equal('$id', ['bush'])
+            Query::equal('$id', ['bush']),
         ]);
 
         $this->assertEquals('bush', $president->getId());
         $this->assertArrayHasKey('animal', $president);
         $this->assertArrayHasKey('votes', $president);
-        $this->assertEquals(0, count($president['votes']));
+        $this->assertCount(0, $president->getDocuments('votes'));
 
         $president = $database->findOne('presidents', [
             Query::select([
                 '*',
                 'votes.*',
             ]),
-            Query::equal('$id', ['trump'])
+            Query::equal('$id', ['trump']),
         ]);
 
         $this->assertEquals('trump', $president->getId());
         $this->assertArrayHasKey('votes', $president);
-        $this->assertEquals(2, count($president['votes']));
-        $this->assertArrayNotHasKey('animals', $president['votes'][0]); // Not exist
+        $this->assertCount(2, $president->getDocuments('votes'));
+        $this->assertArrayNotHasKey('animals', $president->getDocuments('votes')[0]); // Not exist
 
         $president = $database->findOne('presidents', [
             Query::select([
@@ -337,13 +336,13 @@ public function testZoo(): void
                 'votes.*',
                 'votes.animals.*',
             ]),
-            Query::equal('$id', ['trump'])
+            Query::equal('$id', ['trump']),
         ]);
 
         $this->assertEquals('trump', $president->getId());
         $this->assertArrayHasKey('votes', $president);
-        $this->assertEquals(2, count($president['votes']));
-        $this->assertArrayHasKey('animals', $president['votes'][0]); // Exist
+        $this->assertCount(2, $president->getDocuments('votes'));
+        $this->assertArrayHasKey('animals', $president->getDocuments('votes')[0]); // Exist
 
         /**
          * Check Selects queries
@@ -362,7 +361,7 @@ public function testZoo(): void
             [
                 Query::select([
                     'animals.*',
-                ])
+                ]),
             ]
         );
 
@@ -370,7 +369,7 @@ public function testZoo(): void
         $this->assertArrayHasKey('animals', $veterinarian);
         $this->assertArrayNotHasKey('presidents', $veterinarian);
 
-        $animal = $veterinarian['animals'][0];
+        $animal = $veterinarian->getDocuments('animals')[0];
 
         $this->assertArrayHasKey('president', $animal);
         $this->assertEquals('bush', $animal->getAttribute('president')); // Check president is a value
@@ -384,7 +383,7 @@ public function testZoo(): void
                     'animals.*',
                     'animals.zoo.*',
                     'animals.president.*',
-                ])
+                ]),
             ]
         );
 
@@ -392,12 +391,12 @@ public function testZoo(): void
         $this->assertArrayHasKey('animals', $veterinarian);
         $this->assertArrayNotHasKey('presidents', $veterinarian);
 
-        $animal = $veterinarian['animals'][0];
+        $animal = $veterinarian->getDocuments('animals')[0];
 
         $this->assertArrayHasKey('president', $animal);
-        $this->assertEquals('Bush', $animal->getAttribute('president')->getAttribute('lastName')); // Check president is an object
+        $this->assertEquals('Bush', $animal->getDocument('president')->getAttribute('lastName')); // Check president is an object
         $this->assertArrayHasKey('zoo', $animal);
-        $this->assertEquals('Bronx Zoo', $animal->getAttribute('zoo')->getAttribute('name')); // Check zoo is an object
+        $this->assertEquals('Bronx Zoo', $animal->getDocument('zoo')->getAttribute('name')); // Check zoo is an object
     }
 
     public function testSimpleRelationshipPopulation(): void
@@ -405,26 +404,26 @@ public function testSimpleRelationshipPopulation(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Simple test case: user -> post (one-to-many)
-        $database->createCollection('usersSimple');
-        $database->createCollection('postsSimple');
+        $database->createCollection(new Collection(id: 'usersSimple'));
+        $database->createCollection(new Collection(id: 'postsSimple'));
 
-        $database->createAttribute('usersSimple', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsSimple', 'title', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersSimple', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('postsSimple', Attribute::string(key: 'title', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'usersSimple',
             relatedCollection: 'postsSimple',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'posts',
+            key: 'posts',
             twoWayKey: 'author'
-        );
+        ));
 
         // Create some data
         $user = $database->createDocument('usersSimple', new Document([
@@ -449,27 +448,15 @@ public function testSimpleRelationshipPopulation(): void
 
         // fetch user with posts populated
         $fetchedUser = $database->getDocument('usersSimple', 'user1');
-        $posts = $fetchedUser->getAttribute('posts', []);
+        $posts = $fetchedUser->getDocuments('posts');
 
-        // Basic assertions
-        $this->assertIsArray($posts, 'Posts should be an array');
         $this->assertCount(2, $posts, 'Should have 2 posts');
+        $this->assertEquals('First Post', $posts[0]->getAttribute('title'), 'First post title should be populated');
 
-        if (!empty($posts)) {
-            $this->assertInstanceOf(Document::class, $posts[0], 'First post should be a Document object');
-            $this->assertEquals('First Post', $posts[0]->getAttribute('title'), 'First post title should be populated');
-        }
-
-        // fetch posts with author populated
         $fetchedPosts = $database->find('postsSimple');
 
         $this->assertCount(2, $fetchedPosts, 'Should fetch 2 posts');
-
-        if (!empty($fetchedPosts)) {
-            $author = $fetchedPosts[0]->getAttribute('author');
-            $this->assertInstanceOf(Document::class, $author, 'Author should be a Document object');
-            $this->assertEquals('John Doe', $author->getAttribute('name'), 'Author name should be populated');
-        }
+        $this->assertEquals('John Doe', $fetchedPosts[0]->getDocument('author')->getAttribute('name'), 'Author name should be populated');
     }
 
     public function testDeleteRelatedCollection(): void
@@ -477,165 +464,112 @@ public function testDeleteRelatedCollection(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('c1');
-        $database->createCollection('c2');
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createCollection(new Collection(id: 'c2'));
 
         // ONE_TO_ONE
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::oneToOne(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c2'));
+        $database->createRelationship(Relationship::oneToOne(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::oneToOne(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
 
         // ONE_TO_MANY
-        $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createCollection(new Collection(id: 'c2'));
+        $database->createRelationship(Relationship::oneToMany(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::oneToMany(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c2'));
+        $database->createRelationship(Relationship::oneToMany(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::oneToMany(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
 
         // RELATION_MANY_TO_ONE
-        $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createCollection(new Collection(id: 'c2'));
+        $database->createRelationship(Relationship::manyToOne(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::manyToOne(collection: 'c1', relatedCollection: 'c2'));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c2'));
+        $database->createRelationship(Relationship::manyToOne(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
-
-        $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true
-        );
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
+
+        $database->createCollection(new Collection(id: 'c1'));
+        $database->createRelationship(Relationship::manyToOne(collection: 'c1', relatedCollection: 'c2', twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
-        $this->assertCount(0, $collection->getAttribute('attributes'));
-        $this->assertCount(0, $collection->getAttribute('indexes'));
+        $this->assertCount(0, $collection->attributes);
+        $this->assertCount(0, $collection->indexes);
     }
 
     public function testVirtualRelationsAttributes(): void
@@ -643,24 +577,20 @@ public function testVirtualRelationsAttributes(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('v1');
-        $database->createCollection('v2');
+        $database->createCollection(new Collection(id: 'v1'));
+        $database->createCollection(new Collection(id: 'v2'));
 
         /**
          * RELATION_ONE_TO_ONE
          * TwoWay is false no attribute is created on v2
          */
-        $database->createRelationship(
-            collection: 'v1',
-            relatedCollection: 'v2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: false
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'v1', relatedCollection: 'v2'));
 
         try {
             $database->createDocument('v2', new Document([
@@ -680,7 +610,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -709,9 +639,9 @@ public function testVirtualRelationsAttributes(): void
                 '$id' => 'woman',
                 '$permissions' => [
                     Permission::update(Role::any()),
-                    Permission::read(Role::any())
-                ]
-            ]
+                    Permission::read(Role::any()),
+                ],
+            ],
         ]));
 
         $this->assertEquals('man', $doc->getId());
@@ -721,8 +651,8 @@ public function testVirtualRelationsAttributes(): void
                 '$permissions' => [],
                 'v2' => [[
                     '$id' => 'woman',
-                    '$permissions' => []
-                ]]
+                    '$permissions' => [],
+                ]],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -735,12 +665,7 @@ public function testVirtualRelationsAttributes(): void
          * RELATION_ONE_TO_MANY
          * No attribute is created in V1 collection
          */
-        $database->createRelationship(
-            collection: 'v1',
-            relatedCollection: 'v2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'v1', relatedCollection: 'v2', twoWay: true));
 
         try {
             $database->createDocument('v1', new Document([
@@ -749,7 +674,7 @@ public function testVirtualRelationsAttributes(): void
                 'v2' => [ // Expecting Array of arrays or array of strings, object provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -773,7 +698,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [[  // Expecting a string or an object ,array provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]]
+                ]],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -791,9 +716,9 @@ public function testVirtualRelationsAttributes(): void
             'v1' => [
                 '$id' => 'v1_uid',
                 '$permissions' => [
-                    Permission::update(Role::any())
+                    Permission::update(Role::any()),
                 ],
-            ]
+            ],
         ]));
 
         $this->assertEquals('v2_uid', $doc->getId());
@@ -801,14 +726,13 @@ public function testVirtualRelationsAttributes(): void
         /**
          * Test update
          */
-
         try {
             $database->updateDocument('v1', 'v1_uid', new Document([
                 '$permissions' => [],
                 'v2' => [ // Expecting array of arrays or array of strings, object given
                     '$id' => 'v2_uid',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -818,7 +742,7 @@ public function testVirtualRelationsAttributes(): void
         try {
             $database->updateDocument('v1', 'v1_uid', new Document([
                 '$permissions' => [],
-                'v2' => 'v2_uid'
+                'v2' => 'v2_uid',
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -831,7 +755,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [
                     '$id' => null, // Invalid value
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -844,7 +768,7 @@ public function testVirtualRelationsAttributes(): void
          */
         try {
             $database->find('v2', [
-                //@phpstan-ignore-next-line
+                // @phpstan-ignore-next-line
                 Query::equal('v1', [['doc1']]),
             ]);
             $this->fail('Failed to throw exception');
@@ -867,12 +791,7 @@ public function testVirtualRelationsAttributes(): void
          * RELATION_MANY_TO_ONE
          * No attribute is created in V2 collection
          */
-        $database->createRelationship(
-            collection: 'v1',
-            relatedCollection: 'v2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'v1', relatedCollection: 'v2', twoWay: true));
 
         try {
             $database->createDocument('v1', new Document([
@@ -881,7 +800,7 @@ public function testVirtualRelationsAttributes(): void
                 'v2' => [[ // Expecting an object or a string array provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]]
+                ]],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -905,7 +824,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [ // Expecting an array, object provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -936,7 +855,7 @@ public function testVirtualRelationsAttributes(): void
                     Permission::update(Role::any()),
                     Permission::read(Role::any()),
                 ],
-            ]
+            ],
         ]));
 
         $this->assertEquals('doc1', $doc->getId());
@@ -957,7 +876,7 @@ public function testVirtualRelationsAttributes(): void
         try {
             $database->updateDocument('v2', 'doc2', new Document([
                 '$permissions' => [],
-                'v1' => null
+                'v1' => null,
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -970,14 +889,13 @@ public function testVirtualRelationsAttributes(): void
          * RELATION_MANY_TO_MANY
          * No attribute on V1/v2 collections only on junction table
          */
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'v1',
             relatedCollection: 'v2',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'students',
+            key: 'students',
             twoWayKey: 'classes'
-        );
+        ));
 
         try {
             $database->createDocument('v1', new Document([
@@ -1006,7 +924,7 @@ public function testVirtualRelationsAttributes(): void
                 'classes' => [ // Expected array, object provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -1034,7 +952,6 @@ public function testVirtualRelationsAttributes(): void
         /**
          * Success for later test update
          */
-
         $doc = $database->createDocument('v1', new Document([
             '$id' => 'class1',
             '$permissions' => [
@@ -1046,17 +963,17 @@ public function testVirtualRelationsAttributes(): void
                     '$id' => 'Richard',
                     '$permissions' => [
                         Permission::update(Role::any()),
-                        Permission::read(Role::any())
-                    ]
+                        Permission::read(Role::any()),
+                    ],
                 ],
                 [
                     '$id' => 'Bill',
                     '$permissions' => [
                         Permission::update(Role::any()),
-                        Permission::read(Role::any())
-                    ]
-                ]
-            ]
+                        Permission::read(Role::any()),
+                    ],
+                ],
+            ],
         ]));
 
         $this->assertEquals('class1', $doc->getId());
@@ -1071,9 +988,9 @@ public function testVirtualRelationsAttributes(): void
                     '$id' => 'Richard',
                     '$permissions' => [
                         Permission::update(Role::any()),
-                        Permission::read(Role::any())
-                    ]
-                ]
+                        Permission::read(Role::any()),
+                    ],
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -1086,7 +1003,7 @@ public function testVirtualRelationsAttributes(): void
                     Permission::update(Role::any()),
                     Permission::read(Role::any()),
                 ],
-                'students' => 'Richard'
+                'students' => 'Richard',
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -1094,167 +1011,23 @@ public function testVirtualRelationsAttributes(): void
         }
     }
 
-    public function testStructureValidationAfterRelationsAttribute(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            // Schemaless mode allows unknown attributes, so structure validation won't reject them
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection("structure_1", [], [], [Permission::create(Role::any())]);
-        $database->createCollection("structure_2", [], [], [Permission::create(Role::any())]);
-
-        $database->createRelationship(
-            collection: "structure_1",
-            relatedCollection: "structure_2",
-            type: Database::RELATION_ONE_TO_ONE,
-        );
-
-        try {
-            $database->createDocument('structure_1', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                ],
-                'structure_2' => '100',
-                'name' => 'Frozen', // Unknown attribute 'name' after relation attribute
-            ]));
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-    }
-
-
-    public function testNoChangeUpdateDocumentWithRelationWithoutPermission(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-        $attribute = new Document([
-            '$id' => ID::custom("name"),
-            'type' => Database::VAR_STRING,
-            'size' => 100,
-            'required' => false,
-            'default' => null,
-            'signed' => false,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $permissions = [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::delete(Role::any()),
-        ];
-        for ($i = 1; $i < 6; $i++) {
-            $database->createCollection("level{$i}", [$attribute], [], $permissions);
-        }
-
-        for ($i = 1; $i < 5; $i++) {
-            $collectionId = $i;
-            $relatedCollectionId = $i + 1;
-            $database->createRelationship(
-                collection: "level{$collectionId}",
-                relatedCollection: "level{$relatedCollectionId}",
-                type: Database::RELATION_ONE_TO_ONE,
-                id: "level{$relatedCollectionId}"
-            );
-        }
-
-        // Create document with relationship with nested data
-        $level1 = $database->createDocument('level1', new Document([
-            '$id' => 'level1',
-            '$permissions' => [],
-            'name' => 'Level 1',
-            'level2' => [
-                '$id' => 'level2',
-                '$permissions' => [],
-                'name' => 'Level 2',
-                'level3' => [
-                    '$id' => 'level3',
-                    '$permissions' => [],
-                    'name' => 'Level 3',
-                    'level4' => [
-                        '$id' => 'level4',
-                        '$permissions' => [],
-                        'name' => 'Level 4',
-                        'level5' => [
-                            '$id' => 'level5',
-                            '$permissions' => [],
-                            'name' => 'Level 5',
-                        ]
-                    ],
-                ],
-            ],
-        ]));
-        $database->updateDocument('level1', $level1->getId(), new Document($level1->getArrayCopy()));
-        $updatedLevel1 = $database->getDocument('level1', $level1->getId());
-        $this->assertEquals($level1, $updatedLevel1);
-
-        try {
-            $database->updateDocument('level1', $level1->getId(), $level1->setAttribute('name', 'haha'));
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(AuthorizationException::class, $e);
-        }
-        $level1->setAttribute('name', 'Level 1');
-        $database->updateCollection('level3', [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ], false);
-        $level2 = $level1->getAttribute('level2');
-        $level3 = $level2->getAttribute('level3');
-
-        $level3->setAttribute('name', 'updated value');
-        $level2->setAttribute('level3', $level3);
-        $level1->setAttribute('level2', $level2);
-
-        $level1 = $database->updateDocument('level1', $level1->getId(), $level1);
-        $this->assertEquals('updated value', $level1['level2']['level3']['name']);
-
-        for ($i = 1; $i < 6; $i++) {
-            $database->deleteCollection("level{$i}");
-        }
-    }
-
-
-
     public function testUpdateAttributeRenameRelationshipTwoWay(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('rnRsTestA');
-        $database->createCollection('rnRsTestB');
+        $database->createCollection(new Collection(id: 'rnRsTestA'));
+        $database->createCollection(new Collection(id: 'rnRsTestB'));
 
-        $database->createAttribute('rnRsTestB', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('rnRsTestB', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            'rnRsTestA',
-            'rnRsTestB',
-            Database::RELATION_ONE_TO_ONE,
-            true
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'rnRsTestA', relatedCollection: 'rnRsTestB', twoWay: true));
 
         $docA = $database->createDocument('rnRsTestA', new Document([
             '$permissions' => [
@@ -1265,8 +1038,8 @@ public function testUpdateAttributeRenameRelationshipTwoWay(): void
             ],
             'rnRsTestB' => [
                 '$id' => 'b1',
-                'name' => 'B1'
-            ]
+                'name' => 'B1',
+            ],
         ]));
 
         $docB = $database->getDocument('rnRsTestB', 'b1');
@@ -1290,82 +1063,7 @@ public function testUpdateAttributeRenameRelationshipTwoWay(): void
         // Check our data is OK
         $docA = $database->getDocument('rnRsTestA', $docA->getId());
         $this->assertArrayHasKey('rnRsTestB_renamed_2', $docA->getAttributes());
-        $this->assertEquals($docB->getId(), $docA->getAttribute('rnRsTestB_renamed_2')['$id']);
-    }
-
-    public function testNoInvalidKeysWithRelationships(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-        $database->createCollection('species');
-        $database->createCollection('creatures');
-        $database->createCollection('characteristics');
-
-        $database->createAttribute('species', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('creatures', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('characteristics', 'name', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'species',
-            relatedCollection: 'creatures',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'creature',
-            twoWayKey:'species'
-        );
-        $database->createRelationship(
-            collection: 'creatures',
-            relatedCollection: 'characteristics',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'characteristic',
-            twoWayKey:'creature'
-        );
-
-        $species = $database->createDocument('species', new Document([
-            '$id' => ID::custom('1'),
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'name' => 'Canine',
-            'creature' => [
-                '$id' => ID::custom('1'),
-                '$permissions' => [
-                    Permission::read(Role::any()),
-                ],
-                'name' => 'Dog',
-                'characteristic' => [
-                    '$id' => ID::custom('1'),
-                    '$permissions' => [
-                        Permission::read(Role::any()),
-                        Permission::update(Role::any()),
-                    ],
-                    'name' => 'active',
-                ]
-            ]
-        ]));
-        $database->updateDocument('species', $species->getId(), new Document([
-            '$id' => ID::custom('1'),
-            '$collection' => 'species',
-            'creature' => [
-                '$id' => ID::custom('1'),
-                '$collection' => 'creatures',
-                'characteristic' => [
-                    '$id' => ID::custom('1'),
-                    'name' => 'active',
-                    '$collection' => 'characteristics',
-                ]
-            ]
-        ]));
-
-        $updatedSpecies = $database->getDocument('species', $species->getId());
-
-        $this->assertEquals($species, $updatedSpecies);
+        $this->assertEquals($docB->getId(), $docA->getDocument('rnRsTestB_renamed_2')->getId());
     }
 
     public function testSelectRelationshipAttributes(): void
@@ -1373,27 +1071,27 @@ public function testSelectRelationshipAttributes(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('make');
-        $database->createCollection('model');
+        $database->createCollection(new Collection(id: 'make'));
+        $database->createCollection(new Collection(id: 'model'));
 
-        $database->createAttribute('make', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('make', 'origin', Database::VAR_STRING, 255, true);
-        $database->createAttribute('model', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('model', 'year', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('make', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('make', Attribute::string(key: 'origin', required: true));
+        $database->createAttribute('model', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('model', Attribute::integer(key: 'year', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'make',
             relatedCollection: 'model',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'models',
-            twoWayKey: 'make',
-        );
+            key: 'models',
+            twoWayKey: 'make'
+        ));
 
         $database->createDocument('make', new Document([
             '$id' => 'ford',
@@ -1432,11 +1130,11 @@ public function testSelectRelationshipAttributes(): void
         }
 
         $this->assertEquals('Ford', $make['name']);
-        $this->assertEquals(2, \count($make['models']));
-        $this->assertEquals('Fiesta', $make['models'][0]['name']);
-        $this->assertEquals('Focus', $make['models'][1]['name']);
-        $this->assertArrayNotHasKey('year', $make['models'][0]);
-        $this->assertArrayNotHasKey('year', $make['models'][1]);
+        $this->assertCount(2, $make->getDocuments('models'));
+        $this->assertEquals('Fiesta', $make->getDocuments('models')[0]->getAttribute('name'));
+        $this->assertEquals('Focus', $make->getDocuments('models')[1]->getAttribute('name'));
+        $this->assertArrayNotHasKey('year', $make->getDocuments('models')[0]);
+        $this->assertArrayNotHasKey('year', $make->getDocuments('models')[1]);
         $this->assertArrayHasKey('$id', $make);
         $this->assertArrayHasKey('$sequence', $make);
         $this->assertArrayHasKey('$permissions', $make);
@@ -1551,743 +1249,217 @@ public function testSelectRelationshipAttributes(): void
         }
 
         $this->assertEquals('Ford', $make['name']);
-        $this->assertEquals(2, \count($make['models']));
-        $this->assertArrayNotHasKey('name', $make['models'][0]);
-        $this->assertArrayNotHasKey('name', $make['models'][1]);
-        $this->assertEquals(2010, $make['models'][0]['year']);
-        $this->assertEquals(2011, $make['models'][1]['year']);
+        $this->assertCount(2, $make->getDocuments('models'));
+        $this->assertArrayNotHasKey('name', $make->getDocuments('models')[0]);
+        $this->assertArrayNotHasKey('name', $make->getDocuments('models')[1]);
+        $this->assertEquals(2010, $make->getDocuments('models')[0]->getAttribute('year'));
+        $this->assertEquals(2011, $make->getDocuments('models')[1]->getAttribute('year'));
 
         // Select all parent attributes, all child attributes
         $make = $database->findOne('make', [
             Query::select(['*', 'models.*']),
         ]);
 
-        if ($make->isEmpty()) {
-            throw new Exception('Make not found');
-        }
-
-        $this->assertEquals('Ford', $make['name']);
-        $this->assertEquals(2, \count($make['models']));
-        $this->assertEquals('Fiesta', $make['models'][0]['name']);
-        $this->assertEquals('Focus', $make['models'][1]['name']);
-        $this->assertEquals(2010, $make['models'][0]['year']);
-        $this->assertEquals(2011, $make['models'][1]['year']);
-
-        // Select all parent attributes, all child attributes
-        // Must select parent if selecting children
-        $make = $database->findOne('make', [
-            Query::select(['models.*']),
-        ]);
-
-        if ($make->isEmpty()) {
-            throw new Exception('Make not found');
-        }
-
-        $this->assertEquals('Ford', $make['name']);
-        $this->assertEquals(2, \count($make['models']));
-        $this->assertEquals('Fiesta', $make['models'][0]['name']);
-        $this->assertEquals('Focus', $make['models'][1]['name']);
-        $this->assertEquals(2010, $make['models'][0]['year']);
-        $this->assertEquals(2011, $make['models'][1]['year']);
-
-        // Select all parent attributes, no child attributes
-        $make = $database->findOne('make', [
-            Query::select(['name']),
-        ]);
-
-        if ($make->isEmpty()) {
-            throw new Exception('Make not found');
-        }
-        $this->assertEquals('Ford', $make['name']);
-        $this->assertArrayNotHasKey('models', $make);
-
-        // Select some parent attributes, all child attributes
-        $make = $database->findOne('make', [
-            Query::select(['name', 'models.*']),
-        ]);
-
-        $this->assertEquals('Ford', $make['name']);
-        $this->assertEquals(2, \count($make['models']));
-
-        /*
-         * FROM CHILD TO PARENT
-         */
-
-        // Select some parent attributes, some child attributes
-        $model = $database->findOne('model', [
-            Query::select(['name', 'make.name']),
-        ]);
-
-        $this->assertEquals('Fiesta', $model['name']);
-        $this->assertEquals('Ford', $model['make']['name']);
-        $this->assertArrayNotHasKey('origin', $model['make']);
-        $this->assertArrayNotHasKey('year', $model);
-        $this->assertArrayHasKey('name', $model);
-
-        // Select all parent attributes, some child attributes
-        $model = $database->findOne('model', [
-            Query::select(['*', 'make.name']),
-        ]);
-
-        $this->assertEquals('Fiesta', $model['name']);
-        $this->assertEquals('Ford', $model['make']['name']);
-        $this->assertArrayHasKey('year', $model);
-
-        // Select all parent attributes, all child attributes
-        $model = $database->findOne('model', [
-            Query::select(['*', 'make.*']),
-        ]);
-
-        $this->assertEquals('Fiesta', $model['name']);
-        $this->assertEquals('Ford', $model['make']['name']);
-        $this->assertArrayHasKey('year', $model);
-        $this->assertArrayHasKey('name', $model['make']);
-
-        // Select all parent attributes, no child attributes
-        $model = $database->findOne('model', [
-            Query::select(['*']),
-        ]);
-
-        $this->assertEquals('Fiesta', $model['name']);
-        $this->assertArrayHasKey('make', $model);
-        $this->assertArrayHasKey('year', $model);
-
-        // Select some parent attributes, all child attributes
-        $model = $database->findOne('model', [
-            Query::select(['name', 'make.*']),
-        ]);
-
-        $this->assertEquals('Fiesta', $model['name']);
-        $this->assertEquals('Ford', $model['make']['name']);
-        $this->assertEquals('USA', $model['make']['origin']);
-    }
-
-    public function testInheritRelationshipPermissions(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('lawns', permissions: [Permission::create(Role::any())], documentSecurity: true);
-        $database->createCollection('trees', permissions: [Permission::create(Role::any())], documentSecurity: true);
-        $database->createCollection('birds', permissions: [Permission::create(Role::any())], documentSecurity: true);
-
-        $database->createAttribute('lawns', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('trees', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('birds', 'name', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'lawns',
-            relatedCollection: 'trees',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'lawn',
-            onDelete: Database::RELATION_MUTATE_CASCADE,
-        );
-        $database->createRelationship(
-            collection: 'trees',
-            relatedCollection: 'birds',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            onDelete: Database::RELATION_MUTATE_SET_NULL,
-        );
-
-        $permissions = [
-            Permission::read(Role::any()),
-            Permission::read(Role::user('user1')),
-            Permission::update(Role::user('user1')),
-            Permission::delete(Role::user('user2')),
-        ];
-
-        $database->createDocument('lawns', new Document([
-            '$id' => 'lawn1',
-            '$permissions' => $permissions,
-            'name' => 'Lawn 1',
-            'trees' => [
-                [
-                    '$id' => 'tree1',
-                    'name' => 'Tree 1',
-                    'birds' => [
-                        [
-                            '$id' => 'bird1',
-                            'name' => 'Bird 1',
-                        ],
-                        [
-                            '$id' => 'bird2',
-                            'name' => 'Bird 2',
-                        ],
-                    ],
-                ],
-            ],
-        ]));
-
-        $lawn1 = $database->getDocument('lawns', 'lawn1');
-        $this->assertEquals($permissions, $lawn1->getPermissions());
-        $this->assertEquals($permissions, $lawn1['trees'][0]->getPermissions());
-        $this->assertEquals($permissions, $lawn1['trees'][0]['birds'][0]->getPermissions());
-        $this->assertEquals($permissions, $lawn1['trees'][0]['birds'][1]->getPermissions());
-
-        $tree1 = $database->getDocument('trees', 'tree1');
-        $this->assertEquals($permissions, $tree1->getPermissions());
-        $this->assertEquals($permissions, $tree1['lawn']->getPermissions());
-        $this->assertEquals($permissions, $tree1['birds'][0]->getPermissions());
-        $this->assertEquals($permissions, $tree1['birds'][1]->getPermissions());
-    }
-
-    /**
-     * @depends testInheritRelationshipPermissions
-     */
-    public function testEnforceRelationshipPermissions(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-        $lawn1 = $database->getDocument('lawns', 'lawn1');
-        $this->assertEquals('Lawn 1', $lawn1['name']);
-
-        // Try update root document
-        try {
-            $database->updateDocument(
-                'lawns',
-                $lawn1->getId(),
-                $lawn1->setAttribute('name', 'Lawn 1 Updated')
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "update" permission for role "user:user1". Only "["any"]" scopes are allowed and "["user:user1"]" was given.', $e->getMessage());
-        }
-
-        // Try delete root document
-        try {
-            $database->deleteDocument(
-                'lawns',
-                $lawn1->getId(),
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "delete" permission for role "user:user2". Only "["any"]" scopes are allowed and "["user:user2"]" was given.', $e->getMessage());
-        }
-
-        $tree1 = $database->getDocument('trees', 'tree1');
-
-        // Try update nested document
-        try {
-            $database->updateDocument(
-                'trees',
-                $tree1->getId(),
-                $tree1->setAttribute('name', 'Tree 1 Updated')
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "update" permission for role "user:user1". Only "["any"]" scopes are allowed and "["user:user1"]" was given.', $e->getMessage());
-        }
-
-        // Try delete nested document
-        try {
-            $database->deleteDocument(
-                'trees',
-                $tree1->getId(),
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "delete" permission for role "user:user2". Only "["any"]" scopes are allowed and "["user:user2"]" was given.', $e->getMessage());
-        }
-
-        $bird1 = $database->getDocument('birds', 'bird1');
-
-        // Try update multi-level nested document
-        try {
-            $database->updateDocument(
-                'birds',
-                $bird1->getId(),
-                $bird1->setAttribute('name', 'Bird 1 Updated')
-            );
-            $this->fail('Failed to throw exception when updating document with missing permissions');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "update" permission for role "user:user1". Only "["any"]" scopes are allowed and "["user:user1"]" was given.', $e->getMessage());
-        }
-
-        // Try delete multi-level nested document
-        try {
-            $database->deleteDocument(
-                'birds',
-                $bird1->getId(),
-            );
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Missing "delete" permission for role "user:user2". Only "["any"]" scopes are allowed and "["user:user2"]" was given.', $e->getMessage());
-        }
-
-        $this->getDatabase()->getAuthorization()->addRole(Role::user('user1')->toString());
-
-        $bird1 = $database->getDocument('birds', 'bird1');
-
-        // Try update multi-level nested document
-        $bird1 = $database->updateDocument(
-            'birds',
-            $bird1->getId(),
-            $bird1->setAttribute('name', 'Bird 1 Updated')
-        );
-
-        $this->assertEquals('Bird 1 Updated', $bird1['name']);
-
-        $this->getDatabase()->getAuthorization()->addRole(Role::user('user2')->toString());
-
-        // Try delete multi-level nested document
-        $deleted = $database->deleteDocument(
-            'birds',
-            $bird1->getId(),
-        );
-
-        $this->assertEquals(true, $deleted);
-        $tree1 = $database->getDocument('trees', 'tree1');
-        $this->assertEquals(1, count($tree1['birds']));
-
-        // Try update nested document
-        $tree1 = $database->updateDocument(
-            'trees',
-            $tree1->getId(),
-            $tree1->setAttribute('name', 'Tree 1 Updated')
-        );
-
-        $this->assertEquals('Tree 1 Updated', $tree1['name']);
-
-        // Try delete nested document
-        $deleted = $database->deleteDocument(
-            'trees',
-            $tree1->getId(),
-        );
-
-        $this->assertEquals(true, $deleted);
-        $lawn1 = $database->getDocument('lawns', 'lawn1');
-        $this->assertEquals(0, count($lawn1['trees']));
-
-        // Create document with no permissions
-        $database->createDocument('lawns', new Document([
-            '$id' => 'lawn2',
-            'name' => 'Lawn 2',
-            'trees' => [
-                [
-                    '$id' => 'tree2',
-                    'name' => 'Tree 2',
-                    'birds' => [
-                        [
-                            '$id' => 'bird3',
-                            'name' => 'Bird 3',
-                        ],
-                    ],
-                ],
-            ],
-        ]));
-
-        $lawn2 = $database->getDocument('lawns', 'lawn2');
-        $this->assertEquals(true, $lawn2->isEmpty());
-
-        $tree2 = $database->getDocument('trees', 'tree2');
-        $this->assertEquals(true, $tree2->isEmpty());
-
-        $bird3 = $database->getDocument('birds', 'bird3');
-        $this->assertEquals(true, $bird3->isEmpty());
-    }
-
-    public function testCreateRelationshipMissingCollection(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Collection not found');
-
-        $database->createRelationship(
-            collection: 'missing',
-            relatedCollection: 'missing',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-    }
-
-    public function testCreateRelationshipMissingRelatedCollection(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('test');
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Related collection not found');
-
-        $database->createRelationship(
-            collection: 'test',
-            relatedCollection: 'missing',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-    }
-
-    public function testCreateDuplicateRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('test1');
-        $database->createCollection('test2');
-
-        $database->createRelationship(
-            collection: 'test1',
-            relatedCollection: 'test2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Attribute already exists');
-
-        $database->createRelationship(
-            collection: 'test1',
-            relatedCollection: 'test2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-    }
-
-    public function testCreateInvalidRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('test3');
-        $database->createCollection('test4');
-
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Invalid relationship type');
-
-        $database->createRelationship(
-            collection: 'test3',
-            relatedCollection: 'test4',
-            type: 'invalid',
-            twoWay: true,
-        );
-    }
-
-
-    public function testDeleteMissingRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        try {
-            $database->deleteRelationship('test', 'test2');
-            $this->fail('Failed to throw exception');
-        } catch (\Throwable $e) {
-            $this->assertEquals('Relationship not found', $e->getMessage());
-        }
-    }
-
-    public function testCreateInvalidIntValueRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('invalid1');
-        $database->createCollection('invalid2');
-
-        $database->createRelationship(
-            collection: 'invalid1',
-            relatedCollection: 'invalid2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-
-        $this->expectException(RelationshipException::class);
-        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-
-        $database->createDocument('invalid1', new Document([
-            '$id' => ID::unique(),
-            'invalid2' => 10,
-        ]));
-    }
-
-    /**
-     * @depends testCreateInvalidIntValueRelationship
-     */
-    public function testCreateInvalidObjectValueRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $this->expectException(RelationshipException::class);
-        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-
-        $database->createDocument('invalid1', new Document([
-            '$id' => ID::unique(),
-            'invalid2' => new \stdClass(),
-        ]));
-    }
-
-    /**
-     * @depends testCreateInvalidIntValueRelationship
-     */
-    public function testCreateInvalidArrayIntValueRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createRelationship(
-            collection: 'invalid1',
-            relatedCollection: 'invalid2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'invalid3',
-            twoWayKey: 'invalid4',
-        );
-
-        $this->expectException(RelationshipException::class);
-        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
-
-        $database->createDocument('invalid1', new Document([
-            '$id' => ID::unique(),
-            'invalid3' => [10],
-        ]));
-    }
-
-    public function testCreateEmptyValueRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
         }
 
-        $database->createCollection('null1');
-        $database->createCollection('null2');
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertCount(2, $make->getDocuments('models'));
+        $this->assertEquals('Fiesta', $make->getDocuments('models')[0]->getAttribute('name'));
+        $this->assertEquals('Focus', $make->getDocuments('models')[1]->getAttribute('name'));
+        $this->assertEquals(2010, $make->getDocuments('models')[0]->getAttribute('year'));
+        $this->assertEquals(2011, $make->getDocuments('models')[1]->getAttribute('year'));
 
-        $database->createRelationship(
-            collection: 'null1',
-            relatedCollection: 'null2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: 'null1',
-            relatedCollection: 'null2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'null3',
-            twoWayKey: 'null4',
-        );
-        $database->createRelationship(
-            collection: 'null1',
-            relatedCollection: 'null2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'null4',
-            twoWayKey: 'null5',
-        );
-        $database->createRelationship(
-            collection: 'null1',
-            relatedCollection: 'null2',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'null6',
-            twoWayKey: 'null7',
-        );
+        // Select all parent attributes, all child attributes
+        // Must select parent if selecting children
+        $make = $database->findOne('make', [
+            Query::select(['models.*']),
+        ]);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null2' => null,
-        ]));
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
+        }
 
-        $this->assertEquals(null, $document->getAttribute('null2'));
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertCount(2, $make->getDocuments('models'));
+        $this->assertEquals('Fiesta', $make->getDocuments('models')[0]->getAttribute('name'));
+        $this->assertEquals('Focus', $make->getDocuments('models')[1]->getAttribute('name'));
+        $this->assertEquals(2010, $make->getDocuments('models')[0]->getAttribute('year'));
+        $this->assertEquals(2011, $make->getDocuments('models')[1]->getAttribute('year'));
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null1' => null,
-        ]));
+        // Select all parent attributes, no child attributes
+        $make = $database->findOne('make', [
+            Query::select(['name']),
+        ]);
 
-        $this->assertEquals(null, $document->getAttribute('null1'));
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
+        }
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertArrayNotHasKey('models', $make);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null3' => null,
-        ]));
+        // Select some parent attributes, all child attributes
+        $make = $database->findOne('make', [
+            Query::select(['name', 'models.*']),
+        ]);
 
-        // One to many will be empty array instead of null
-        $this->assertEquals([], $document->getAttribute('null3'));
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertCount(2, $make->getDocuments('models'));
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null4' => null,
-        ]));
+        /*
+         * FROM CHILD TO PARENT
+         */
 
-        $this->assertEquals(null, $document->getAttribute('null4'));
+        // Select some parent attributes, some child attributes
+        $model = $database->findOne('model', [
+            Query::select(['name', 'make.name']),
+        ]);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null4' => null,
-        ]));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model->getDocument('make')->getAttribute('name'));
+        $this->assertArrayNotHasKey('origin', $model->getDocument('make'));
+        $this->assertArrayNotHasKey('year', $model);
+        $this->assertArrayHasKey('name', $model);
 
-        $this->assertEquals(null, $document->getAttribute('null4'));
+        // Select all parent attributes, some child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*', 'make.name']),
+        ]);
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null5' => null,
-        ]));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model->getDocument('make')->getAttribute('name'));
+        $this->assertArrayHasKey('year', $model);
 
-        $this->assertEquals([], $document->getAttribute('null5'));
+        // Select all parent attributes, all child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*', 'make.*']),
+        ]);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null6' => null,
-        ]));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model->getDocument('make')->getAttribute('name'));
+        $this->assertArrayHasKey('year', $model);
+        $this->assertArrayHasKey('name', $model->getDocument('make'));
 
-        $this->assertEquals([], $document->getAttribute('null6'));
+        // Select all parent attributes, no child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*']),
+        ]);
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null7' => null,
-        ]));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertArrayHasKey('make', $model);
+        $this->assertArrayHasKey('year', $model);
+
+        // Select some parent attributes, all child attributes
+        $model = $database->findOne('model', [
+            Query::select(['name', 'make.*']),
+        ]);
 
-        $this->assertEquals([], $document->getAttribute('null7'));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model->getDocument('make')->getAttribute('name'));
+        $this->assertEquals('USA', $model->getDocument('make')->getAttribute('origin'));
     }
 
-    public function testUpdateRelationshipToExistingKey(): void
+    public function testInheritRelationshipPermissions(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('ovens');
-        $database->createCollection('cakes');
+        $database->createCollection(new Collection(id: 'lawns', permissions: [Permission::create(Role::any())]));
+        $database->createCollection(new Collection(id: 'trees', permissions: [Permission::create(Role::any())]));
+        $database->createCollection(new Collection(id: 'birds', permissions: [Permission::create(Role::any())]));
 
-        $database->createAttribute('ovens', 'maxTemp', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('ovens', 'owner', Database::VAR_STRING, 255, true);
-        $database->createAttribute('cakes', 'height', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('cakes', 'colour', Database::VAR_STRING, 255, true);
+        $database->createAttribute('lawns', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('trees', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('birds', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'ovens',
-            relatedCollection: 'cakes',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createRelationship(Relationship::oneToMany(
+            collection: 'lawns',
+            relatedCollection: 'trees',
             twoWay: true,
-            id: 'cakes',
-            twoWayKey: 'oven'
-        );
+            twoWayKey: 'lawn',
+            onDelete: ForeignKeyAction::Cascade
+        ));
+        $database->createRelationship(Relationship::manyToMany(collection: 'trees', relatedCollection: 'birds', twoWay: true, onDelete: ForeignKeyAction::SetNull));
 
-        try {
-            $database->updateRelationship('ovens', 'cakes', newKey: 'owner');
-            $this->fail('Failed to throw exception');
-        } catch (DuplicateException $e) {
-            $this->assertEquals('Relationship already exists', $e->getMessage());
-        }
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::read(Role::user('user1')),
+            Permission::update(Role::user('user1')),
+            Permission::delete(Role::user('user2')),
+        ];
 
-        try {
-            $database->updateRelationship('ovens', 'cakes', newTwoWayKey: 'height');
-            $this->fail('Failed to throw exception');
-        } catch (DuplicateException $e) {
-            $this->assertEquals('Related attribute already exists', $e->getMessage());
-        }
+        $database->createDocument('lawns', new Document([
+            '$id' => 'lawn1',
+            '$permissions' => $permissions,
+            'name' => 'Lawn 1',
+            'trees' => [
+                [
+                    '$id' => 'tree1',
+                    'name' => 'Tree 1',
+                    'birds' => [
+                        [
+                            '$id' => 'bird1',
+                            'name' => 'Bird 1',
+                        ],
+                        [
+                            '$id' => 'bird2',
+                            'name' => 'Bird 2',
+                        ],
+                    ],
+                ],
+            ],
+        ]));
+
+        $lawn1 = $database->getDocument('lawns', 'lawn1');
+        $this->assertEquals($permissions, $lawn1->getPermissions());
+        $this->assertEquals($permissions, $lawn1->getDocuments('trees')[0]->getPermissions());
+        $this->assertEquals($permissions, $lawn1->getDocuments('trees')[0]->getDocuments('birds')[0]->getPermissions());
+        $this->assertEquals($permissions, $lawn1->getDocuments('trees')[0]->getDocuments('birds')[1]->getPermissions());
+
+        $tree1 = $database->getDocument('trees', 'tree1');
+        $this->assertEquals($permissions, $tree1->getPermissions());
+        $this->assertEquals($permissions, $tree1->getDocument('lawn')->getPermissions());
+        $this->assertEquals($permissions, $tree1->getDocuments('birds')[0]->getPermissions());
+        $this->assertEquals($permissions, $tree1->getDocuments('birds')[1]->getPermissions());
     }
 
     public function testUpdateDocumentsRelationships(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForBatchOperations() || !$this->getDatabase()->getAdapter()->getSupportForRelationships()) {
+        if (! $this->getDatabase()->getAdapter()->supports(Capability::BatchOperations) || ! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $this->getDatabase()->createCollection('testUpdateDocumentsRelationships1', attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'size' => 767,
-                'required' => true,
-            ])
+        $this->getDatabase()->createCollection(new Collection(id: 'testUpdateDocumentsRelationships1', attributes: [
+            Attribute::string(key: 'string', size: 767, required: true),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $this->getDatabase()->createCollection('testUpdateDocumentsRelationships2', attributes: [
-            new Document([
-                '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
-                'size' => 767,
-                'required' => true,
-            ])
+        $this->getDatabase()->createCollection(new Collection(id: 'testUpdateDocumentsRelationships2', attributes: [
+            Attribute::string(key: 'string', size: 767, required: true),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $this->getDatabase()->createRelationship(
-            collection: 'testUpdateDocumentsRelationships1',
-            relatedCollection: 'testUpdateDocumentsRelationships2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $this->getDatabase()->createRelationship(Relationship::oneToOne(collection: 'testUpdateDocumentsRelationships1', relatedCollection: 'testUpdateDocumentsRelationships2', twoWay: true));
 
         $this->getDatabase()->createDocument('testUpdateDocumentsRelationships1', new Document([
             '$id' => 'doc1',
@@ -2297,11 +1469,11 @@ public function testUpdateDocumentsRelationships(): void
         $this->getDatabase()->createDocument('testUpdateDocumentsRelationships2', new Document([
             '$id' => 'doc1',
             'string' => 'text📝',
-            'testUpdateDocumentsRelationships1' => 'doc1'
+            'testUpdateDocumentsRelationships1' => 'doc1',
         ]));
 
         $sisterDocument = $this->getDatabase()->getDocument('testUpdateDocumentsRelationships2', 'doc1');
-        $this->assertNotNull($sisterDocument);
+        $this->assertFalse($sisterDocument->isEmpty());
 
         $this->getDatabase()->updateDocuments('testUpdateDocumentsRelationships1', new Document([
             'string' => 'text📝 updated',
@@ -2309,50 +1481,45 @@ public function testUpdateDocumentsRelationships(): void
 
         $document = $this->getDatabase()->findOne('testUpdateDocumentsRelationships1');
 
-        $this->assertNotFalse($document);
+        $this->assertFalse($document->isEmpty());
         $this->assertEquals('text📝 updated', $document->getAttribute('string'));
 
         $sisterDocument = $this->getDatabase()->getDocument('testUpdateDocumentsRelationships2', 'doc1');
-        $this->assertNotNull($sisterDocument);
+        $this->assertFalse($sisterDocument->isEmpty());
 
-        $relationalDocument = $sisterDocument->getAttribute('testUpdateDocumentsRelationships1');
+        $relationalDocument = $sisterDocument->getDocument('testUpdateDocumentsRelationships1');
         $this->assertEquals('text📝 updated', $relationalDocument->getAttribute('string'));
 
         // Check relationship value updating between each other.
         $this->getDatabase()->deleteRelationship('testUpdateDocumentsRelationships1', 'testUpdateDocumentsRelationships2');
 
-        $this->getDatabase()->createRelationship(
-            collection: 'testUpdateDocumentsRelationships1',
-            relatedCollection: 'testUpdateDocumentsRelationships2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $this->getDatabase()->createRelationship(Relationship::oneToMany(collection: 'testUpdateDocumentsRelationships1', relatedCollection: 'testUpdateDocumentsRelationships2', twoWay: true));
 
         for ($i = 2; $i < 11; $i++) {
             $this->getDatabase()->createDocument('testUpdateDocumentsRelationships1', new Document([
-                '$id' => 'doc' . $i,
+                '$id' => 'doc'.$i,
                 'string' => 'text📝',
             ]));
 
             $this->getDatabase()->createDocument('testUpdateDocumentsRelationships2', new Document([
-                '$id' => 'doc' . $i,
+                '$id' => 'doc'.$i,
                 'string' => 'text📝',
-                'testUpdateDocumentsRelationships1' => 'doc' . $i
+                'testUpdateDocumentsRelationships1' => 'doc'.$i,
             ]));
         }
 
         $this->getDatabase()->updateDocuments('testUpdateDocumentsRelationships2', new Document([
-            'testUpdateDocumentsRelationships1' => null
+            'testUpdateDocumentsRelationships1' => null,
         ]));
 
         $this->getDatabase()->updateDocuments('testUpdateDocumentsRelationships2', new Document([
-            'testUpdateDocumentsRelationships1' => 'doc1'
+            'testUpdateDocumentsRelationships1' => 'doc1',
         ]));
 
         $documents = $this->getDatabase()->find('testUpdateDocumentsRelationships2');
 
         foreach ($documents as $document) {
-            $this->assertEquals('doc1', $document->getAttribute('testUpdateDocumentsRelationships1')->getId());
+            $this->assertEquals('doc1', $document->getDocument('testUpdateDocumentsRelationships1')->getId());
         }
     }
 
@@ -2361,205 +1528,95 @@ public function testUpdateDocumentWithRelationships(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('userProfiles', [
-            new Document([
-                '$id' => ID::custom('username'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+        $database->createCollection(new Collection(id: 'userProfiles', attributes: [
+            Attribute::string(key: 'username', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('links', [
-            new Document([
-                '$id' => ID::custom('title'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'links', attributes: [
+            Attribute::string(key: 'title', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('videos', [
-            new Document([
-                '$id' => ID::custom('title'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'videos', attributes: [
+            Attribute::string(key: 'title', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('products', [
-            new Document([
-                '$id' => ID::custom('title'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'products', attributes: [
+            Attribute::string(key: 'title', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('settings', [
-            new Document([
-                '$id' => ID::custom('metaTitle'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'settings', attributes: [
+            Attribute::string(key: 'metaTitle', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('appearance', [
-            new Document([
-                '$id' => ID::custom('metaTitle'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'appearance', attributes: [
+            Attribute::string(key: 'metaTitle', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('group', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'group', attributes: [
+            Attribute::string(key: 'name', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('community', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 700,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: 'community', attributes: [
+            Attribute::string(key: 'name', size: 700, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'links',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'links'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'userProfiles', relatedCollection: 'links', key: 'links'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'videos',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'videos'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'userProfiles', relatedCollection: 'videos', key: 'videos'));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'userProfiles',
             relatedCollection: 'products',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'products',
-            twoWayKey: 'userProfile',
-        );
+            key: 'products',
+            twoWayKey: 'userProfile'
+        ));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'settings',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'settings'
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'userProfiles', relatedCollection: 'settings', key: 'settings'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'appearance',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'appearance'
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'userProfiles', relatedCollection: 'appearance', key: 'appearance'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'group',
-            type: Database::RELATION_MANY_TO_ONE,
-            id: 'group'
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'userProfiles', relatedCollection: 'group', key: 'group'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'community',
-            type: Database::RELATION_MANY_TO_ONE,
-            id: 'community'
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'userProfiles', relatedCollection: 'community', key: 'community'));
 
         $profile = $database->createDocument('userProfiles', new Document([
             '$id' => '1',
@@ -2599,13 +1656,13 @@ public function testUpdateDocumentWithRelationships(): void
                 'name' => 'Community 1',
             ],
         ]));
-        $this->assertEquals('link1', $profile->getAttribute('links')[0]->getId());
-        $this->assertEquals('settings1', $profile->getAttribute('settings')->getId());
-        $this->assertEquals('group1', $profile->getAttribute('group')->getId());
-        $this->assertEquals('community1', $profile->getAttribute('community')->getId());
-        $this->assertEquals('video1', $profile->getAttribute('videos')[0]->getId());
-        $this->assertEquals('product1', $profile->getAttribute('products')[0]->getId());
-        $this->assertEquals('appearance1', $profile->getAttribute('appearance')->getId());
+        $this->assertEquals('link1', $profile->getDocuments('links')[0]->getId());
+        $this->assertEquals('settings1', $profile->getDocument('settings')->getId());
+        $this->assertEquals('group1', $profile->getDocument('group')->getId());
+        $this->assertEquals('community1', $profile->getDocument('community')->getId());
+        $this->assertEquals('video1', $profile->getDocuments('videos')[0]->getId());
+        $this->assertEquals('product1', $profile->getDocuments('products')[0]->getId());
+        $this->assertEquals('appearance1', $profile->getDocument('appearance')->getId());
 
         $profile->setAttribute('links', [
             [
@@ -2626,15 +1683,15 @@ public function testUpdateDocumentWithRelationships(): void
 
         $updatedProfile = $database->updateDocument('userProfiles', '1', $profile);
 
-        $this->assertEquals('New Link Value', $updatedProfile->getAttribute('links')[0]->getAttribute('title'));
-        $this->assertEquals('New Meta Title', $updatedProfile->getAttribute('settings')->getAttribute('metaTitle'));
-        $this->assertEquals('New Group Name', $updatedProfile->getAttribute('group')->getAttribute('name'));
+        $this->assertEquals('New Link Value', $updatedProfile->getDocuments('links')[0]->getAttribute('title'));
+        $this->assertEquals('New Meta Title', $updatedProfile->getDocument('settings')->getAttribute('metaTitle'));
+        $this->assertEquals('New Group Name', $updatedProfile->getDocument('group')->getAttribute('name'));
 
         // This is the point of test, related documents should be present if they are not updated
-        $this->assertEquals('Video 1', $updatedProfile->getAttribute('videos')[0]->getAttribute('title'));
-        $this->assertEquals('Product 1', $updatedProfile->getAttribute('products')[0]->getAttribute('title'));
-        $this->assertEquals('Meta Title', $updatedProfile->getAttribute('appearance')->getAttribute('metaTitle'));
-        $this->assertEquals('Community 1', $updatedProfile->getAttribute('community')->getAttribute('name'));
+        $this->assertEquals('Video 1', $updatedProfile->getDocuments('videos')[0]->getAttribute('title'));
+        $this->assertEquals('Product 1', $updatedProfile->getDocuments('products')[0]->getAttribute('title'));
+        $this->assertEquals('Meta Title', $updatedProfile->getDocument('appearance')->getAttribute('metaTitle'));
+        $this->assertEquals('Community 1', $updatedProfile->getDocument('community')->getAttribute('name'));
 
         // updating document using two way key in one to many relationship
         $product = $database->getDocument('products', 'product1');
@@ -2643,10 +1700,10 @@ public function testUpdateDocumentWithRelationships(): void
             'username' => 'updated user value',
         ]);
         $updatedProduct = $database->updateDocument('products', 'product1', $product);
-        $this->assertEquals('updated user value', $updatedProduct->getAttribute('userProfile')->getAttribute('username'));
+        $this->assertEquals('updated user value', $updatedProduct->getDocument('userProfile')->getAttribute('username'));
         $this->assertEquals('Product 1', $updatedProduct->getAttribute('title'));
         $this->assertEquals('product1', $updatedProduct->getId());
-        $this->assertEquals('1', $updatedProduct->getAttribute('userProfile')->getId());
+        $this->assertEquals('1', $updatedProduct->getDocument('userProfile')->getId());
 
         $database->deleteCollection('userProfiles');
         $database->deleteCollection('links');
@@ -2667,39 +1724,28 @@ public function testMultiDocumentNestedRelationships(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create collections: car -> customer -> inspection
-        $database->createCollection('car');
-        $database->createAttribute('car', 'plateNumber', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'car'));
+        $database->createAttribute('car', Attribute::string(key: 'plateNumber', required: true));
 
-        $database->createCollection('customer');
-        $database->createAttribute('customer', 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'customer'));
+        $database->createAttribute('customer', Attribute::string(key: 'name', required: true));
 
-        $database->createCollection('inspection');
-        $database->createAttribute('inspection', 'type', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'inspection'));
+        $database->createAttribute('inspection', Attribute::string(key: 'type', required: true));
 
         // Create relationships
         // car -> customer (many to one, one-way to avoid circular references)
-        $database->createRelationship(
-            collection: 'car',
-            relatedCollection: 'customer',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: false,
-            id: 'customer',
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'car', relatedCollection: 'customer', key: 'customer'));
 
         // customer -> inspection (one to many, one-way)
-        $database->createRelationship(
-            collection: 'customer',
-            relatedCollection: 'inspection',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: false,
-            id: 'inspections',
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'customer', relatedCollection: 'inspection', key: 'inspections'));
 
         // Create test data - customers with inspections first
         $database->createDocument('inspection', new Document([
@@ -2815,21 +1861,21 @@ public function testMultiDocumentNestedRelationships(): void
         $this->assertCount(3, $cars);
 
         $this->assertEquals('ABC123', $cars[0]['plateNumber']);
-        $this->assertEquals('Customer 1', $cars[0]['customer']['name']);
-        $this->assertCount(2, $cars[0]['customer']['inspections']);
-        $this->assertEquals('annual', $cars[0]['customer']['inspections'][0]['type']);
-        $this->assertEquals('safety', $cars[0]['customer']['inspections'][1]['type']);
+        $this->assertEquals('Customer 1', $cars[0]->getDocument('customer')->getAttribute('name'));
+        $this->assertCount(2, $cars[0]->getDocument('customer')->getDocuments('inspections'));
+        $this->assertEquals('annual', $cars[0]->getDocument('customer')->getDocuments('inspections')[0]->getAttribute('type'));
+        $this->assertEquals('safety', $cars[0]->getDocument('customer')->getDocuments('inspections')[1]->getAttribute('type'));
 
         $this->assertEquals('DEF456', $cars[1]['plateNumber']);
-        $this->assertEquals('Customer 2', $cars[1]['customer']['name']);
-        $this->assertCount(2, $cars[1]['customer']['inspections']);
-        $this->assertEquals('emissions', $cars[1]['customer']['inspections'][0]['type']);
-        $this->assertEquals('annual', $cars[1]['customer']['inspections'][1]['type']);
+        $this->assertEquals('Customer 2', $cars[1]->getDocument('customer')->getAttribute('name'));
+        $this->assertCount(2, $cars[1]->getDocument('customer')->getDocuments('inspections'));
+        $this->assertEquals('emissions', $cars[1]->getDocument('customer')->getDocuments('inspections')[0]->getAttribute('type'));
+        $this->assertEquals('annual', $cars[1]->getDocument('customer')->getDocuments('inspections')[1]->getAttribute('type'));
 
         $this->assertEquals('GHI789', $cars[2]['plateNumber']);
-        $this->assertEquals('Customer 3', $cars[2]['customer']['name']);
-        $this->assertCount(1, $cars[2]['customer']['inspections']);
-        $this->assertEquals('safety', $cars[2]['customer']['inspections'][0]['type']);
+        $this->assertEquals('Customer 3', $cars[2]->getDocument('customer')->getAttribute('name'));
+        $this->assertCount(1, $cars[2]->getDocument('customer')->getDocuments('inspections'));
+        $this->assertEquals('safety', $cars[2]->getDocument('customer')->getDocuments('inspections')[0]->getAttribute('type'));
 
         // Test with createDocuments as well
         $database->deleteDocument('car', 'car1');
@@ -2867,9 +1913,9 @@ public function testMultiDocumentNestedRelationships(): void
 
         // Verify all cars still have nested relationships after batch create
         $this->assertCount(3, $cars);
-        $this->assertCount(2, $cars[0]['customer']['inspections']);
-        $this->assertCount(2, $cars[1]['customer']['inspections']);
-        $this->assertCount(1, $cars[2]['customer']['inspections']);
+        $this->assertCount(2, $cars[0]->getDocument('customer')->getDocuments('inspections'));
+        $this->assertCount(2, $cars[1]->getDocument('customer')->getDocuments('inspections'));
+        $this->assertCount(1, $cars[2]->getDocument('customer')->getDocuments('inspections'));
 
         // Clean up
         $database->deleteCollection('inspection');
@@ -2887,39 +1933,38 @@ public function testNestedDocumentCreationWithDepthHandling(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create three collections with chained relationships: Order -> Product -> Store
-        $database->createCollection('orderDepthTest');
-        $database->createCollection('productDepthTest');
-        $database->createCollection('storeDepthTest');
+        $database->createCollection(new Collection(id: 'orderDepthTest'));
+        $database->createCollection(new Collection(id: 'productDepthTest'));
+        $database->createCollection(new Collection(id: 'storeDepthTest'));
 
-        $database->createAttribute('orderDepthTest', 'orderNumber', Database::VAR_STRING, 255, true);
-        $database->createAttribute('productDepthTest', 'productName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('storeDepthTest', 'storeName', Database::VAR_STRING, 255, true);
+        $database->createAttribute('orderDepthTest', Attribute::string(key: 'orderNumber', required: true));
+        $database->createAttribute('productDepthTest', Attribute::string(key: 'productName', required: true));
+        $database->createAttribute('storeDepthTest', Attribute::string(key: 'storeName', required: true));
 
         // Order -> Product (many-to-one)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'orderDepthTest',
             relatedCollection: 'productDepthTest',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'product',
+            key: 'product',
             twoWayKey: 'orders'
-        );
+        ));
 
         // Product -> Store (many-to-one)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'productDepthTest',
             relatedCollection: 'storeDepthTest',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'store',
+            key: 'store',
             twoWayKey: 'products'
-        );
+        ));
 
         // First, create a store that will be referenced by the nested product
         $store = $database->createDocument('storeDepthTest', new Document([
@@ -3022,28 +2067,28 @@ public function testRelationshipTypeQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create author -> posts relationship
-        $database->createCollection('authorsFilter');
-        $database->createCollection('postsFilter');
+        $database->createCollection(new Collection(id: 'authorsFilter'));
+        $database->createCollection(new Collection(id: 'postsFilter'));
 
-        $database->createAttribute('authorsFilter', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('authorsFilter', 'age', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('postsFilter', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsFilter', 'published', Database::VAR_BOOLEAN, 0, true);
+        $database->createAttribute('authorsFilter', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('authorsFilter', Attribute::integer(key: 'age', required: true));
+        $database->createAttribute('postsFilter', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('postsFilter', Attribute::boolean(key: 'published', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'authorsFilter',
             relatedCollection: 'postsFilter',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'posts',
+            key: 'posts',
             twoWayKey: 'author'
-        );
+        ));
 
         // Create test data
         $author1 = $database->createDocument('authorsFilter', new Document([
@@ -3109,21 +2154,20 @@ public function testRelationshipTypeQueries(): void
         $database->deleteCollection('authorsFilter');
         $database->deleteCollection('postsFilter');
 
-        $database->createCollection('usersOto');
-        $database->createCollection('profilesOto');
+        $database->createCollection(new Collection(id: 'usersOto'));
+        $database->createCollection(new Collection(id: 'profilesOto'));
 
-        $database->createAttribute('usersOto', 'username', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profilesOto', 'bio', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersOto', Attribute::string(key: 'username', required: true));
+        $database->createAttribute('profilesOto', Attribute::string(key: 'bio', required: true));
 
         // ONE_TO_ONE with twoWay=true
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'usersOto',
             relatedCollection: 'profilesOto',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'profile',
+            key: 'profile',
             twoWayKey: 'user'
-        );
+        ));
 
         $user1 = $database->createDocument('usersOto', new Document([
             '$id' => 'user1',
@@ -3156,21 +2200,20 @@ public function testRelationshipTypeQueries(): void
         $database->deleteCollection('usersOto');
         $database->deleteCollection('profilesOto');
 
-        $database->createCollection('commentsMto');
-        $database->createCollection('usersMto');
+        $database->createCollection(new Collection(id: 'commentsMto'));
+        $database->createCollection(new Collection(id: 'usersMto'));
 
-        $database->createAttribute('commentsMto', 'content', Database::VAR_STRING, 255, true);
-        $database->createAttribute('usersMto', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('commentsMto', Attribute::string(key: 'content', required: true));
+        $database->createAttribute('usersMto', Attribute::string(key: 'name', required: true));
 
         // MANY_TO_ONE with twoWay=true
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'commentsMto',
             relatedCollection: 'usersMto',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'commenter',
+            key: 'commenter',
             twoWayKey: 'comments'
-        );
+        ));
 
         $userA = $database->createDocument('usersMto', new Document([
             '$id' => 'userA',
@@ -3209,21 +2252,20 @@ public function testRelationshipTypeQueries(): void
         $database->deleteCollection('commentsMto');
         $database->deleteCollection('usersMto');
 
-        $database->createCollection('studentsMtm');
-        $database->createCollection('coursesMtm');
+        $database->createCollection(new Collection(id: 'studentsMtm'));
+        $database->createCollection(new Collection(id: 'coursesMtm'));
 
-        $database->createAttribute('studentsMtm', 'studentName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('coursesMtm', 'courseName', Database::VAR_STRING, 255, true);
+        $database->createAttribute('studentsMtm', Attribute::string(key: 'studentName', required: true));
+        $database->createAttribute('coursesMtm', Attribute::string(key: 'courseName', required: true));
 
         // MANY_TO_MANY
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'studentsMtm',
             relatedCollection: 'coursesMtm',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'enrolledCourses',
+            key: 'enrolledCourses',
             twoWayKey: 'students'
-        );
+        ));
 
         $student1 = $database->createDocument('studentsMtm', new Document([
             '$id' => 'student1',
@@ -3265,25 +2307,25 @@ public function testQueryByRelationshipId(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('usersRelId');
-        $database->createCollection('postsRelId');
+        $database->createCollection(new Collection(id: 'usersRelId'));
+        $database->createCollection(new Collection(id: 'postsRelId'));
 
-        $database->createAttribute('usersRelId', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsRelId', 'title', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersRelId', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('postsRelId', Attribute::string(key: 'title', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'postsRelId',
             relatedCollection: 'usersRelId',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'user',
+            key: 'user',
             twoWayKey: 'posts'
-        );
+        ));
 
         // Create test users
         $user1 = $database->createDocument('usersRelId', new Document([
@@ -3368,20 +2410,19 @@ public function testQueryByRelationshipId(): void
         $database->deleteCollection('postsRelId');
 
         // Test ONE_TO_ONE relationship - query profile by user.$id
-        $database->createCollection('usersOtoId');
-        $database->createCollection('profilesOtoId');
+        $database->createCollection(new Collection(id: 'usersOtoId'));
+        $database->createCollection(new Collection(id: 'profilesOtoId'));
 
-        $database->createAttribute('usersOtoId', 'username', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profilesOtoId', 'bio', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersOtoId', Attribute::string(key: 'username', required: true));
+        $database->createAttribute('profilesOtoId', Attribute::string(key: 'bio', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'usersOtoId',
             relatedCollection: 'profilesOtoId',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'profile',
+            key: 'profile',
             twoWayKey: 'user'
-        );
+        ));
 
         $userOto1 = $database->createDocument('usersOtoId', new Document([
             '$id' => 'userOto1',
@@ -3421,20 +2462,19 @@ public function testQueryByRelationshipId(): void
         $database->deleteCollection('profilesOtoId');
 
         // Test MANY_TO_MANY relationship - query projects by developer.$id
-        $database->createCollection('developersMtmId');
-        $database->createCollection('projectsMtmId');
+        $database->createCollection(new Collection(id: 'developersMtmId'));
+        $database->createCollection(new Collection(id: 'projectsMtmId'));
 
-        $database->createAttribute('developersMtmId', 'devName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('projectsMtmId', 'projectName', Database::VAR_STRING, 255, true);
+        $database->createAttribute('developersMtmId', Attribute::string(key: 'devName', required: true));
+        $database->createAttribute('projectsMtmId', Attribute::string(key: 'projectName', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'developersMtmId',
             relatedCollection: 'projectsMtmId',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'projects',
+            key: 'projects',
             twoWayKey: 'developers'
-        );
+        ));
 
         $dev1 = $database->createDocument('developersMtmId', new Document([
             '$id' => 'dev1',
@@ -3573,30 +2613,30 @@ public function testRelationshipFilterQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Setup test collections
-        $database->createCollection('productsQt');
-        $database->createCollection('vendorsQt');
+        $database->createCollection(new Collection(id: 'productsQt'));
+        $database->createCollection(new Collection(id: 'vendorsQt'));
 
-        $database->createAttribute('productsQt', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('productsQt', 'price', Database::VAR_FLOAT, 0, true);
-        $database->createAttribute('vendorsQt', 'company', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vendorsQt', 'rating', Database::VAR_FLOAT, 0, true);
-        $database->createAttribute('vendorsQt', 'email', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vendorsQt', 'verified', Database::VAR_BOOLEAN, 0, true);
+        $database->createAttribute('productsQt', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('productsQt', Attribute::double(key: 'price', required: true));
+        $database->createAttribute('vendorsQt', Attribute::string(key: 'company', required: true));
+        $database->createAttribute('vendorsQt', Attribute::double(key: 'rating', required: true));
+        $database->createAttribute('vendorsQt', Attribute::string(key: 'email', required: true));
+        $database->createAttribute('vendorsQt', Attribute::boolean(key: 'verified', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'productsQt',
             relatedCollection: 'vendorsQt',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'vendor',
+            key: 'vendor',
             twoWayKey: 'products'
-        );
+        ));
 
         // Create test vendors
         $database->createDocument('vendorsQt', new Document([
@@ -3653,70 +2693,70 @@ public function testRelationshipFilterQueries(): void
 
         // Query::equal()
         $products = $database->find('productsQt', [
-            Query::equal('vendor.company', ['Acme Corp'])
+            Query::equal('vendor.company', ['Acme Corp']),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product1', $products[0]->getId());
 
         // Query::notEqual()
         $products = $database->find('productsQt', [
-            Query::notEqual('vendor.company', ['Budget Vendors'])
+            Query::notEqual('vendor.company', ['Budget Vendors']),
         ]);
         $this->assertCount(2, $products);
 
         // Query::lessThan()
         $products = $database->find('productsQt', [
-            Query::lessThan('vendor.rating', 4.0)
+            Query::lessThan('vendor.rating', 4.0),
         ]);
         $this->assertCount(2, $products); // vendor2 (3.8) and vendor3 (2.5)
 
         // Query::lessThanEqual()
         $products = $database->find('productsQt', [
-            Query::lessThanEqual('vendor.rating', 3.8)
+            Query::lessThanEqual('vendor.rating', 3.8),
         ]);
         $this->assertCount(2, $products);
 
         // Query::greaterThan()
         $products = $database->find('productsQt', [
-            Query::greaterThan('vendor.rating', 4.0)
+            Query::greaterThan('vendor.rating', 4.0),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product1', $products[0]->getId());
 
         // Query::greaterThanEqual()
         $products = $database->find('productsQt', [
-            Query::greaterThanEqual('vendor.rating', 3.8)
+            Query::greaterThanEqual('vendor.rating', 3.8),
         ]);
         $this->assertCount(2, $products); // vendor1 (4.5) and vendor2 (3.8)
 
         // Query::startsWith()
         $products = $database->find('productsQt', [
-            Query::startsWith('vendor.email', 'sales@')
+            Query::startsWith('vendor.email', 'sales@'),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product1', $products[0]->getId());
 
         // Query::endsWith()
         $products = $database->find('productsQt', [
-            Query::endsWith('vendor.email', '.com')
+            Query::endsWith('vendor.email', '.com'),
         ]);
         $this->assertCount(3, $products);
 
         // Query::contains()
         $products = $database->find('productsQt', [
-            Query::contains('vendor.company', ['Corp'])
+            Query::contains('vendor.company', ['Corp']),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product1', $products[0]->getId());
 
         // Boolean query
         $products = $database->find('productsQt', [
-            Query::equal('vendor.verified', [true])
+            Query::equal('vendor.verified', [true]),
         ]);
         $this->assertCount(2, $products); // vendor1 and vendor2 are verified
 
         $products = $database->find('productsQt', [
-            Query::equal('vendor.verified', [false])
+            Query::equal('vendor.verified', [false]),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product3', $products[0]->getId());
@@ -3725,7 +2765,7 @@ public function testRelationshipFilterQueries(): void
         $products = $database->find('productsQt', [
             Query::greaterThan('vendor.rating', 3.0),
             Query::equal('vendor.verified', [true]),
-            Query::startsWith('vendor.company', 'Acme')
+            Query::startsWith('vendor.company', 'Acme'),
         ]);
         $this->assertCount(1, $products);
         $this->assertEquals('product1', $products[0]->getId());
@@ -3740,36 +2780,37 @@ public function testRelationshipSpatialQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create Restaurants -> Suppliers relationship with spatial attributes
-        $database->createCollection('restaurantsSpatial');
-        $database->createCollection('suppliersSpatial');
+        $database->createCollection(new Collection(id: 'restaurantsSpatial'));
+        $database->createCollection(new Collection(id: 'suppliersSpatial'));
 
-        $database->createAttribute('restaurantsSpatial', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('restaurantsSpatial', 'location', Database::VAR_POINT, 0, true);
+        $database->createAttribute('restaurantsSpatial', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('restaurantsSpatial', Attribute::point(key: 'location', required: true));
 
-        $database->createAttribute('suppliersSpatial', 'company', Database::VAR_STRING, 255, true);
-        $database->createAttribute('suppliersSpatial', 'warehouseLocation', Database::VAR_POINT, 0, true);
-        $database->createAttribute('suppliersSpatial', 'deliveryArea', Database::VAR_POLYGON, 0, true);
-        $database->createAttribute('suppliersSpatial', 'deliveryRoute', Database::VAR_LINESTRING, 0, true);
+        $database->createAttribute('suppliersSpatial', Attribute::string(key: 'company', required: true));
+        $database->createAttribute('suppliersSpatial', Attribute::point(key: 'warehouseLocation', required: true));
+        $database->createAttribute('suppliersSpatial', Attribute::polygon(key: 'deliveryArea', required: true));
+        $database->createAttribute('suppliersSpatial', Attribute::linestring(key: 'deliveryRoute', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'restaurantsSpatial',
             relatedCollection: 'suppliersSpatial',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'supplier',
+            key: 'supplier',
             twoWayKey: 'restaurants'
-        );
+        ));
 
         // Create suppliers with spatial data (coordinates are [longitude, latitude])
         $supplier1 = $database->createDocument('suppliersSpatial', new Document([
@@ -3782,13 +2823,13 @@ public function testRelationshipSpatialQueries(): void
                 [-73.9, 40.7],
                 [-73.9, 40.8],
                 [-74.1, 40.8],
-                [-74.1, 40.7]
+                [-74.1, 40.7],
             ],
             'deliveryRoute' => [
                 [-74.0060, 40.7128],
                 [-73.9851, 40.7589],
-                [-73.9857, 40.7484]
-            ]
+                [-73.9857, 40.7484],
+            ],
         ]));
 
         $supplier2 = $database->createDocument('suppliersSpatial', new Document([
@@ -3801,13 +2842,13 @@ public function testRelationshipSpatialQueries(): void
                 [-118.1, 34.0],
                 [-118.1, 34.1],
                 [-118.3, 34.1],
-                [-118.3, 34.0]
+                [-118.3, 34.0],
             ],
             'deliveryRoute' => [
                 [-118.2437, 34.0522],
                 [-118.2468, 34.0407],
-                [-118.2456, 34.0336]
-            ]
+                [-118.2456, 34.0336],
+            ],
         ]));
 
         $supplier3 = $database->createDocument('suppliersSpatial', new Document([
@@ -3820,13 +2861,13 @@ public function testRelationshipSpatialQueries(): void
                 [-104.8, 39.7],
                 [-104.8, 39.8],
                 [-105.1, 39.8],
-                [-105.1, 39.7]
+                [-105.1, 39.7],
             ],
             'deliveryRoute' => [
                 [-104.9903, 39.7392],
                 [-104.9847, 39.7294],
-                [-104.9708, 39.7197]
-            ]
+                [-104.9708, 39.7197],
+            ],
         ]));
 
         // Create restaurants
@@ -3835,7 +2876,7 @@ public function testRelationshipSpatialQueries(): void
             '$permissions' => [Permission::read(Role::any())],
             'name' => 'NYC Diner',
             'location' => [-74.0060, 40.7128],
-            'supplier' => 'supplier1'
+            'supplier' => 'supplier1',
         ]));
 
         $database->createDocument('restaurantsSpatial', new Document([
@@ -3843,7 +2884,7 @@ public function testRelationshipSpatialQueries(): void
             '$permissions' => [Permission::read(Role::any())],
             'name' => 'LA Bistro',
             'location' => [-118.2437, 34.0522],
-            'supplier' => 'supplier2'
+            'supplier' => 'supplier2',
         ]));
 
         $database->createDocument('restaurantsSpatial', new Document([
@@ -3851,46 +2892,46 @@ public function testRelationshipSpatialQueries(): void
             '$permissions' => [Permission::read(Role::any())],
             'name' => 'Denver Steakhouse',
             'location' => [-104.9903, 39.7392],
-            'supplier' => 'supplier3'
+            'supplier' => 'supplier3',
         ]));
 
         // distanceLessThan on relationship point attribute
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0)
+            Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
 
         // distanceEqual on relationship point attribute
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::distanceEqual('supplier.warehouseLocation', [-74.0060, 40.7128], 0.0)
+            Query::distanceEqual('supplier.warehouseLocation', [-74.0060, 40.7128], 0.0),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
 
         // distanceGreaterThan on relationship point attribute
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::distanceGreaterThan('supplier.warehouseLocation', [-74.0060, 40.7128], 10.0)
+            Query::distanceGreaterThan('supplier.warehouseLocation', [-74.0060, 40.7128], 10.0),
         ]);
         $this->assertCount(2, $restaurants); // LA and Denver suppliers
 
         // distanceNotEqual on relationship point attribute
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::distanceNotEqual('supplier.warehouseLocation', [-74.0060, 40.7128], 0.0)
+            Query::distanceNotEqual('supplier.warehouseLocation', [-74.0060, 40.7128], 0.0),
         ]);
         $this->assertCount(2, $restaurants); // LA and Denver
 
-        // contains on relationship polygon attribute (point inside polygon)
+        // covers on relationship polygon attribute (point inside polygon)
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::contains('supplier.deliveryArea', [[-74.0, 40.75]])
+            Query::contains('supplier.deliveryArea', [[-74.0, 40.75]]),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
 
-        // contains on relationship linestring attribute
+        // covers on relationship linestring attribute
         // Note: ST_Contains on linestrings is implementation-dependent (some DBs require exact point-on-line)
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::contains('supplier.deliveryRoute', [[-74.0060, 40.7128]])
+            Query::contains('supplier.deliveryRoute', [[-74.0060, 40.7128]]),
         ]);
         // Verify query executes (result count depends on DB spatial implementation)
         $this->assertGreaterThanOrEqual(0, count($restaurants));
@@ -3901,10 +2942,10 @@ public function testRelationshipSpatialQueries(): void
             [-74.00, 40.72],
             [-74.00, 40.77],
             [-74.05, 40.77],
-            [-74.05, 40.72]
+            [-74.05, 40.72],
         ];
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::intersects('supplier.deliveryArea', [$testPolygon])
+            Query::intersects('supplier.deliveryArea', [$testPolygon]),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
@@ -3913,10 +2954,10 @@ public function testRelationshipSpatialQueries(): void
         // Note: Linestring intersection semantics vary by DB (MariaDB/MySQL/PostgreSQL differ)
         $testLine = [
             [-74.01, 40.71],
-            [-73.99, 40.76]
+            [-73.99, 40.76],
         ];
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::intersects('supplier.deliveryRoute', [$testLine])
+            Query::intersects('supplier.deliveryRoute', [$testLine]),
         ]);
         // Verify query executes (result count depends on DB spatial implementation)
         $this->assertGreaterThanOrEqual(0, count($restaurants));
@@ -3924,10 +2965,10 @@ public function testRelationshipSpatialQueries(): void
         // crosses on relationship linestring
         $crossingLine = [
             [-74.05, 40.70],
-            [-73.95, 40.80]
+            [-73.95, 40.80],
         ];
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::crosses('supplier.deliveryRoute', [$crossingLine])
+            Query::crosses('supplier.deliveryRoute', [$crossingLine]),
         ]);
         // Result depends on actual geometry intersection
 
@@ -3937,10 +2978,10 @@ public function testRelationshipSpatialQueries(): void
             [-74.00, 40.75],
             [-74.00, 40.85],
             [-74.05, 40.85],
-            [-74.05, 40.75]
+            [-74.05, 40.75],
         ];
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::overlaps('supplier.deliveryArea', [$overlappingPolygon])
+            Query::overlaps('supplier.deliveryArea', [$overlappingPolygon]),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
@@ -3951,10 +2992,10 @@ public function testRelationshipSpatialQueries(): void
             [-73.9, 40.8],
             [-73.9, 40.9],
             [-74.1, 40.9],
-            [-74.1, 40.8]
+            [-74.1, 40.8],
         ];
         $restaurants = $database->find('restaurantsSpatial', [
-            Query::touches('supplier.deliveryArea', [$touchingPolygon])
+            Query::touches('supplier.deliveryArea', [$touchingPolygon]),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
@@ -3962,7 +3003,7 @@ public function testRelationshipSpatialQueries(): void
         // Multiple spatial queries combined
         $restaurants = $database->find('restaurantsSpatial', [
             Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0),
-            Query::contains('supplier.deliveryArea', [[-74.0, 40.75]])
+            Query::contains('supplier.deliveryArea', [[-74.0, 40.75]]),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
@@ -3970,14 +3011,14 @@ public function testRelationshipSpatialQueries(): void
         // Spatial query combined with regular query
         $restaurants = $database->find('restaurantsSpatial', [
             Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0),
-            Query::equal('supplier.company', ['Fresh Foods Inc'])
+            Query::equal('supplier.company', ['Fresh Foods Inc']),
         ]);
         $this->assertCount(1, $restaurants);
         $this->assertEquals('rest1', $restaurants[0]->getId());
 
         // count with spatial relationship query
         $count = $database->count('restaurantsSpatial', [
-            Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0)
+            Query::distanceLessThan('supplier.warehouseLocation', [-74.0060, 40.7128], 1.0),
         ]);
         $this->assertEquals(1, $count);
 
@@ -3994,29 +3035,29 @@ public function testRelationshipVirtualQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Setup ONE_TO_MANY relationship
-        $database->createCollection('teamsParent');
-        $database->createCollection('membersParent');
+        $database->createCollection(new Collection(id: 'teamsParent'));
+        $database->createCollection(new Collection(id: 'membersParent'));
 
-        $database->createAttribute('teamsParent', 'teamName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('teamsParent', 'active', Database::VAR_BOOLEAN, 0, true);
-        $database->createAttribute('membersParent', 'memberName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('membersParent', 'role', Database::VAR_STRING, 255, true);
-        $database->createAttribute('membersParent', 'senior', Database::VAR_BOOLEAN, 0, true);
+        $database->createAttribute('teamsParent', Attribute::string(key: 'teamName', required: true));
+        $database->createAttribute('teamsParent', Attribute::boolean(key: 'active', required: true));
+        $database->createAttribute('membersParent', Attribute::string(key: 'memberName', required: true));
+        $database->createAttribute('membersParent', Attribute::string(key: 'role', required: true));
+        $database->createAttribute('membersParent', Attribute::boolean(key: 'senior', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'teamsParent',
             relatedCollection: 'membersParent',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'members',
+            key: 'members',
             twoWayKey: 'team'
-        );
+        ));
 
         // Create teams
         $database->createDocument('teamsParent', new Document([
@@ -4064,21 +3105,21 @@ public function testRelationshipVirtualQueries(): void
         // Find teams that have senior engineers
         $teams = $database->find('teamsParent', [
             Query::equal('members.role', ['Engineer']),
-            Query::equal('members.senior', [true])
+            Query::equal('members.senior', [true]),
         ]);
         $this->assertCount(1, $teams);
         $this->assertEquals('team1', $teams[0]->getId());
 
         // Find teams with managers
         $teams = $database->find('teamsParent', [
-            Query::equal('members.role', ['Manager'])
+            Query::equal('members.role', ['Manager']),
         ]);
         $this->assertCount(1, $teams);
         $this->assertEquals('team2', $teams[0]->getId());
 
         // Find teams with members named 'Alice'
         $teams = $database->find('teamsParent', [
-            Query::startsWith('members.memberName', 'A')
+            Query::startsWith('members.memberName', 'A'),
         ]);
         $this->assertCount(1, $teams);
         $this->assertEquals('team1', $teams[0]->getId());
@@ -4086,7 +3127,7 @@ public function testRelationshipVirtualQueries(): void
         // No teams with junior managers
         $teams = $database->find('teamsParent', [
             Query::equal('members.role', ['Manager']),
-            Query::equal('members.senior', [true])
+            Query::equal('members.senior', [true]),
         ]);
         $this->assertCount(0, $teams);
 
@@ -4103,28 +3144,28 @@ public function testRelationshipQueryEdgeCases(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Setup test collections
-        $database->createCollection('ordersEdge');
-        $database->createCollection('customersEdge');
+        $database->createCollection(new Collection(id: 'ordersEdge'));
+        $database->createCollection(new Collection(id: 'customersEdge'));
 
-        $database->createAttribute('ordersEdge', 'orderNumber', Database::VAR_STRING, 255, true);
-        $database->createAttribute('ordersEdge', 'total', Database::VAR_FLOAT, 0, true);
-        $database->createAttribute('customersEdge', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('customersEdge', 'age', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('ordersEdge', Attribute::string(key: 'orderNumber', required: true));
+        $database->createAttribute('ordersEdge', Attribute::double(key: 'total', required: true));
+        $database->createAttribute('customersEdge', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('customersEdge', Attribute::integer(key: 'age', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'ordersEdge',
             relatedCollection: 'customersEdge',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'customer',
+            key: 'customer',
             twoWayKey: 'orders'
-        );
+        ));
 
         // Create customer
         $database->createDocument('customersEdge', new Document([
@@ -4145,25 +3186,22 @@ public function testRelationshipQueryEdgeCases(): void
 
         // No matching results
         $orders = $database->find('ordersEdge', [
-            Query::equal('customer.name', ['Jane Doe'])
+            Query::equal('customer.name', ['Jane Doe']),
         ]);
         $this->assertCount(0, $orders);
 
         // Impossible condition (combines to empty set)
         $orders = $database->find('ordersEdge', [
             Query::equal('customer.name', ['John Doe']),
-            Query::equal('customer.age', [25]) // John is 30, not 25
+            Query::equal('customer.age', [25]), // John is 30, not 25
         ]);
         $this->assertCount(0, $orders);
 
-        // Non-existent relationship attribute
         try {
             $database->find('ordersEdge', [
-                Query::equal('nonexistent.attribute', ['value'])
+                Query::equal('nonexistent.attribute', ['value']),
             ]);
-        } catch (\Exception $e) {
-            // Expected - non-existent relationship
-            $this->assertTrue(true);
+        } catch (\Throwable) {
         }
 
         // Null or missing relationship
@@ -4176,14 +3214,14 @@ public function testRelationshipQueryEdgeCases(): void
         ]));
 
         $orders = $database->find('ordersEdge', [
-            Query::equal('customer.name', ['John Doe'])
+            Query::equal('customer.name', ['John Doe']),
         ]);
         $this->assertCount(1, $orders);
 
         // Combining relationship query with regular query
         $orders = $database->find('ordersEdge', [
             Query::equal('customer.name', ['John Doe']),
-            Query::greaterThan('total', 75.00)
+            Query::greaterThan('total', 75.00),
         ]);
         $this->assertCount(1, $orders);
         $this->assertEquals('order1', $orders[0]->getId());
@@ -4192,7 +3230,7 @@ public function testRelationshipQueryEdgeCases(): void
         $orders = $database->find('ordersEdge', [
             Query::equal('customer.name', ['John Doe']),
             Query::limit(1),
-            Query::offset(0)
+            Query::offset(0),
         ]);
         $this->assertCount(1, $orders);
 
@@ -4208,29 +3246,29 @@ public function testRelationshipManyToManyComplex(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Setup MANY_TO_MANY
-        $database->createCollection('developersMtm');
-        $database->createCollection('projectsMtm');
+        $database->createCollection(new Collection(id: 'developersMtm'));
+        $database->createCollection(new Collection(id: 'projectsMtm'));
 
-        $database->createAttribute('developersMtm', 'devName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('developersMtm', 'experience', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('projectsMtm', 'projectName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('projectsMtm', 'budget', Database::VAR_FLOAT, 0, true);
-        $database->createAttribute('projectsMtm', 'priority', Database::VAR_STRING, 50, true);
+        $database->createAttribute('developersMtm', Attribute::string(key: 'devName', required: true));
+        $database->createAttribute('developersMtm', Attribute::integer(key: 'experience', required: true));
+        $database->createAttribute('projectsMtm', Attribute::string(key: 'projectName', required: true));
+        $database->createAttribute('projectsMtm', Attribute::double(key: 'budget', required: true));
+        $database->createAttribute('projectsMtm', Attribute::string(key: 'priority', size: 50, required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'developersMtm',
             relatedCollection: 'projectsMtm',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'assignedProjects',
+            key: 'assignedProjects',
             twoWayKey: 'assignedDevelopers'
-        );
+        ));
 
         // Create developers
         $dev1 = $database->createDocument('developersMtm', new Document([
@@ -4268,33 +3306,33 @@ public function testRelationshipManyToManyComplex(): void
 
         // Find developers on high priority projects
         $developers = $database->find('developersMtm', [
-            Query::equal('assignedProjects.priority', ['high'])
+            Query::equal('assignedProjects.priority', ['high']),
         ]);
         $this->assertCount(2, $developers); // Both assigned to proj1
 
         // Find developers on high budget projects
         $developers = $database->find('developersMtm', [
-            Query::greaterThan('assignedProjects.budget', 50000.00)
+            Query::greaterThan('assignedProjects.budget', 50000.00),
         ]);
         $this->assertCount(2, $developers);
 
         // Find projects with experienced developers
         $projects = $database->find('projectsMtm', [
-            Query::greaterThanEqual('assignedDevelopers.experience', 10)
+            Query::greaterThanEqual('assignedDevelopers.experience', 10),
         ]);
         $this->assertCount(1, $projects);
         $this->assertEquals('proj1', $projects[0]->getId());
 
         // Find projects with junior developers
         $projects = $database->find('projectsMtm', [
-            Query::lessThan('assignedDevelopers.experience', 5)
+            Query::lessThan('assignedDevelopers.experience', 5),
         ]);
         $this->assertCount(2, $projects); // Both projects have dev2
 
         // Combined queries
         $projects = $database->find('projectsMtm', [
             Query::equal('assignedDevelopers.devName', ['Junior Dev']),
-            Query::equal('priority', ['low'])
+            Query::equal('priority', ['low']),
         ]);
         $this->assertCount(1, $projects);
         $this->assertEquals('proj2', $projects[0]->getId());
@@ -4309,8 +3347,9 @@ public function testNestedRelationshipQueriesMultipleDepths(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4319,71 +3358,67 @@ public function testNestedRelationshipQueriesMultipleDepths(): void
         // Also: Employees -> Department (MANY_TO_ONE)
 
         // Level 0: Companies
-        $database->createCollection('companiesNested');
-        $database->createAttribute('companiesNested', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('companiesNested', 'industry', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'companiesNested'));
+        $database->createAttribute('companiesNested', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('companiesNested', Attribute::string(key: 'industry', required: true));
 
         // Level 1: Employees
-        $database->createCollection('employeesNested');
-        $database->createAttribute('employeesNested', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('employeesNested', 'role', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'employeesNested'));
+        $database->createAttribute('employeesNested', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('employeesNested', Attribute::string(key: 'role', required: true));
 
         // Level 1b: Departments (for MANY_TO_ONE)
-        $database->createCollection('departmentsNested');
-        $database->createAttribute('departmentsNested', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('departmentsNested', 'budget', Database::VAR_INTEGER, 0, true);
+        $database->createCollection(new Collection(id: 'departmentsNested'));
+        $database->createAttribute('departmentsNested', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('departmentsNested', Attribute::integer(key: 'budget', required: true));
 
         // Level 2: Projects
-        $database->createCollection('projectsNested');
-        $database->createAttribute('projectsNested', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('projectsNested', 'status', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'projectsNested'));
+        $database->createAttribute('projectsNested', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('projectsNested', Attribute::string(key: 'status', required: true));
 
         // Level 3: Tasks
-        $database->createCollection('tasksNested');
-        $database->createAttribute('tasksNested', 'description', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tasksNested', 'priority', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tasksNested', 'completed', Database::VAR_BOOLEAN, 0, true);
+        $database->createCollection(new Collection(id: 'tasksNested'));
+        $database->createAttribute('tasksNested', Attribute::string(key: 'description', required: true));
+        $database->createAttribute('tasksNested', Attribute::string(key: 'priority', required: true));
+        $database->createAttribute('tasksNested', Attribute::boolean(key: 'completed', required: true));
 
         // Create relationships
         // Companies -> Employees (ONE_TO_MANY)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'companiesNested',
             relatedCollection: 'employeesNested',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'employees',
+            key: 'employees',
             twoWayKey: 'company'
-        );
+        ));
 
         // Employees -> Department (MANY_TO_ONE)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'employeesNested',
             relatedCollection: 'departmentsNested',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'department',
+            key: 'department',
             twoWayKey: 'employees'
-        );
+        ));
 
         // Employees -> Projects (ONE_TO_MANY)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'employeesNested',
             relatedCollection: 'projectsNested',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'projects',
+            key: 'projects',
             twoWayKey: 'employee'
-        );
+        ));
 
         // Projects -> Tasks (ONE_TO_MANY)
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'projectsNested',
             relatedCollection: 'tasksNested',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'tasks',
+            key: 'tasks',
             twoWayKey: 'project'
-        );
+        ));
 
         // Create test data
         $dept1 = $database->createDocument('departmentsNested', new Document([
@@ -4565,29 +3600,29 @@ public function testCountAndSumWithRelationshipQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create Author -> Posts relationship with view count
-        $database->createCollection('authorsCount');
-        $database->createCollection('postsCount');
+        $database->createCollection(new Collection(id: 'authorsCount'));
+        $database->createCollection(new Collection(id: 'postsCount'));
 
-        $database->createAttribute('authorsCount', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('authorsCount', 'age', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('postsCount', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsCount', 'views', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('postsCount', 'published', Database::VAR_BOOLEAN, 0, true);
+        $database->createAttribute('authorsCount', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('authorsCount', Attribute::integer(key: 'age', required: true));
+        $database->createAttribute('postsCount', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('postsCount', Attribute::integer(key: 'views', required: true));
+        $database->createAttribute('postsCount', Attribute::boolean(key: 'published', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'authorsCount',
             relatedCollection: 'postsCount',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'posts',
+            key: 'posts',
             twoWayKey: 'author'
-        );
+        ));
 
         // Create test data
         $author1 = $database->createDocument('authorsCount', new Document([
@@ -4723,26 +3758,30 @@ public function testCountAndSumWithRelationshipQueries(): void
      */
     public function testOrderAndCursorWithRelationshipQueries(): void
     {
+        if (! ($this->getDatabase()->getAdapter()->hasFeature(Feature\Relationships::class))) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('authorsOrder');
-        $database->createCollection('postsOrder');
+        $database->createCollection(new Collection(id: 'authorsOrder'));
+        $database->createCollection(new Collection(id: 'postsOrder'));
 
-        $database->createAttribute('authorsOrder', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('authorsOrder', 'age', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('authorsOrder', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('authorsOrder', Attribute::integer(key: 'age', required: true));
 
-        $database->createAttribute('postsOrder', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsOrder', 'views', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('postsOrder', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('postsOrder', Attribute::integer(key: 'views', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'postsOrder',
             relatedCollection: 'authorsOrder',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'author',
+            key: 'author',
             twoWayKey: 'postsOrder'
-        );
+        ));
 
         // Create authors
         $alice = $database->createDocument('authorsOrder', new Document([
@@ -4787,7 +3826,7 @@ public function testOrderAndCursorWithRelationshipQueries(): void
         $caught = false;
         try {
             $database->find('postsOrder', [
-                Query::orderAsc('author.name')
+                Query::orderAsc('author.name'),
             ]);
         } catch (\Throwable $e) {
             $caught = true;
@@ -4799,12 +3838,12 @@ public function testOrderAndCursorWithRelationshipQueries(): void
         $caught = false;
         try {
             $firstPost = $database->findOne('postsOrder', [
-                Query::orderAsc('title')
+                Query::orderAsc('title'),
             ]);
 
             $database->find('postsOrder', [
                 Query::orderAsc('author.name'),
-                Query::cursorAfter($firstPost)
+                Query::cursorAfter($firstPost),
             ]);
         } catch (\Throwable $e) {
             $caught = true;
@@ -4812,7 +3851,6 @@ public function testOrderAndCursorWithRelationshipQueries(): void
         }
         $this->assertTrue($caught, 'Should throw exception for nested order attribute with cursor');
 
-
         // Clean up
         $database->deleteCollection('authorsOrder');
         $database->deleteCollection('postsOrder');
diff --git a/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php b/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
index 73783270e2..9b61afbb75 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
@@ -3,6 +3,10 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +15,10 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait ManyToManyTests
 {
@@ -19,38 +27,34 @@ public function testManyToManyOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('playlist');
-        $database->createCollection('song');
+        $database->createCollection(new Collection(id: 'playlist'));
+        $database->createCollection(new Collection(id: 'song'));
 
-        $database->createAttribute('playlist', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('song', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('song', 'length', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('playlist', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('song', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('song', Attribute::integer(key: 'length', required: true));
 
-        $database->createRelationship(
-            collection: 'playlist',
-            relatedCollection: 'song',
-            type: Database::RELATION_MANY_TO_MANY,
-            id: 'songs'
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: 'playlist', relatedCollection: 'song', key: 'songs'));
 
         // Check metadata for collection
         $collection = $database->getCollection('playlist');
-        $attributes = $collection->getAttribute('attributes', []);
-
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'songs') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('songs', $attribute['$id']);
-                $this->assertEquals('songs', $attribute['key']);
-                $this->assertEquals('song', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(false, $attribute['options']['twoWay']);
-                $this->assertEquals('playlist', $attribute['options']['twoWayKey']);
+
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'songs') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('songs', $attribute->getId());
+                $this->assertEquals('songs', $attribute->key);
+                $this->assertEquals('song', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(false, $options['twoWay'] ?? null);
+                $this->assertEquals('playlist', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -97,33 +101,35 @@ public function testManyToManyOneWayRelationship(): void
             ],
             'name' => 'Playlist 2',
             'songs' => [
-                'song2'
-            ]
+                'song2',
+            ],
         ]));
 
         // Update a document with non existing related document. It should not get added to the list.
-        $database->updateDocument('playlist', 'playlist1', $playlist1->setAttribute('songs', ['song1','no-song']));
+        $database->updateDocument('playlist', 'playlist1', $playlist1->setAttribute('songs', ['song1', 'no-song']));
 
         $playlist1Document = $database->getDocument('playlist', 'playlist1');
         // Assert document does not contain non existing relation document.
-        $this->assertEquals(1, \count($playlist1Document->getAttribute('songs')));
+        $this->assertEquals(1, \count($playlist1Document->getDocuments('songs')));
 
         $documents = $database->find('playlist', [
             Query::select(['name']),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertArrayNotHasKey('songs', $documents[0]);
 
         // Get document with relationship
         $playlist = $database->getDocument('playlist', 'playlist1');
-        $songs = $playlist->getAttribute('songs', []);
-        $this->assertEquals('song1', $songs[0]['$id']);
+        $songs = $playlist->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('song1', $songs[0]->getId());
         $this->assertArrayNotHasKey('playlist', $songs[0]);
 
         $playlist = $database->getDocument('playlist', 'playlist2');
-        $songs = $playlist->getAttribute('songs', []);
-        $this->assertEquals('song2', $songs[0]['$id']);
+        $songs = $playlist->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('song2', $songs[0]->getId());
         $this->assertArrayNotHasKey('playlist', $songs[0]);
 
         // Get related document
@@ -139,22 +145,26 @@ public function testManyToManyOneWayRelationship(): void
 
         // Select related document attributes
         $playlist = $database->findOne('playlist', [
-            Query::select(['*', 'songs.name'])
+            Query::select(['*', 'songs.name']),
         ]);
 
         if ($playlist->isEmpty()) {
             throw new Exception('Playlist not found');
         }
 
-        $this->assertEquals('Song 1', $playlist->getAttribute('songs')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('length', $playlist->getAttribute('songs')[0]);
+        $songs = $playlist->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 1', $songs[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('length', $songs[0]);
 
         $playlist = $database->getDocument('playlist', 'playlist1', [
-            Query::select(['*', 'songs.name'])
+            Query::select(['*', 'songs.name']),
         ]);
 
-        $this->assertEquals('Song 1', $playlist->getAttribute('songs')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('length', $playlist->getAttribute('songs')[0]);
+        $songs = $playlist->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 1', $songs[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('length', $songs[0]);
 
         // Update root document attribute without altering relationship
         $playlist1 = $database->updateDocument(
@@ -168,7 +178,8 @@ public function testManyToManyOneWayRelationship(): void
         $this->assertEquals('Playlist 1 Updated', $playlist1->getAttribute('name'));
 
         // Update nested document attribute
-        $songs = $playlist1->getAttribute('songs', []);
+        $songs = $playlist1->getDocuments('songs');
+        $this->assertNotEmpty($songs);
         $songs[0]->setAttribute('name', 'Song 1 Updated');
 
         $playlist1 = $database->updateDocument(
@@ -177,9 +188,13 @@ public function testManyToManyOneWayRelationship(): void
             $playlist1->setAttribute('songs', $songs)
         );
 
-        $this->assertEquals('Song 1 Updated', $playlist1->getAttribute('songs')[0]->getAttribute('name'));
+        $songs = $playlist1->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 1 Updated', $songs[0]->getAttribute('name'));
         $playlist1 = $database->getDocument('playlist', 'playlist1');
-        $this->assertEquals('Song 1 Updated', $playlist1->getAttribute('songs')[0]->getAttribute('name'));
+        $songs = $playlist1->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 1 Updated', $songs[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $playlist5 = $database->createDocument('playlist', new Document([
@@ -220,13 +235,17 @@ public function testManyToManyOneWayRelationship(): void
             'songs' => [
                 'song1',
                 'song2',
-                'song5'
-            ]
+                'song5',
+            ],
         ]));
 
-        $this->assertEquals('Song 5', $playlist5->getAttribute('songs')[0]->getAttribute('name'));
+        $songs = $playlist5->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 5', $songs[0]->getAttribute('name'));
         $playlist5 = $database->getDocument('playlist', 'playlist5');
-        $this->assertEquals('Song 5', $playlist5->getAttribute('songs')[0]->getAttribute('name'));
+        $songs = $playlist5->getDocuments('songs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('Song 5', $songs[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -244,8 +263,9 @@ public function testManyToManyOneWayRelationship(): void
 
         // Get document with new relationship key
         $playlist = $database->getDocument('playlist', 'playlist1');
-        $songs = $playlist->getAttribute('newSongs');
-        $this->assertEquals('song2', $songs[0]['$id']);
+        $songs = $playlist->getDocuments('newSongs');
+        $this->assertNotEmpty($songs);
+        $this->assertEquals('song2', $songs[0]->getId());
 
         // Create new document with no relationship
         $database->createDocument('playlist', new Document([
@@ -277,7 +297,7 @@ public function testManyToManyOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'playlist',
             id: 'newSongs',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         $playlist1 = $database->getDocument('playlist', 'playlist1');
@@ -294,13 +314,13 @@ public function testManyToManyOneWayRelationship(): void
 
         // Check relation was set to null
         $playlist1 = $database->getDocument('playlist', 'playlist1');
-        $this->assertEquals(0, \count($playlist1->getAttribute('newSongs')));
+        $this->assertEquals(0, \count($playlist1->getDocuments('newSongs')));
 
         // Change on delete to cascade
         $database->updateRelationship(
             collection: 'playlist',
             id: 'newSongs',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -330,52 +350,48 @@ public function testManyToManyTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('students');
-        $database->createCollection('classes');
+        $database->createCollection(new Collection(id: 'students'));
+        $database->createCollection(new Collection(id: 'classes'));
 
-        $database->createAttribute('students', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('classes', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('classes', 'number', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('students', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('classes', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('classes', Attribute::integer(key: 'number', required: true));
 
-        $database->createRelationship(
-            collection: 'students',
-            relatedCollection: 'classes',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: 'students', relatedCollection: 'classes', twoWay: true));
 
         // Check metadata for collection
         $collection = $database->getCollection('students');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'students') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('students', $attribute['$id']);
-                $this->assertEquals('students', $attribute['key']);
-                $this->assertEquals('students', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('classes', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'students') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('students', $attribute->getId());
+                $this->assertEquals('students', $attribute->key);
+                $this->assertEquals('students', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('classes', $options['twoWayKey'] ?? null);
             }
         }
 
         // Check metadata for related collection
         $collection = $database->getCollection('classes');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'classes') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('classes', $attribute['$id']);
-                $this->assertEquals('classes', $attribute['key']);
-                $this->assertEquals('classes', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('students', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'classes') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('classes', $attribute->getId());
+                $this->assertEquals('classes', $attribute->key);
+                $this->assertEquals('classes', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('students', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -407,7 +423,7 @@ public function testManyToManyTwoWayRelationship(): void
 
         $student1Document = $database->getDocument('students', 'student1');
         // Assert document does not contain non existing relation document.
-        $this->assertEquals(1, \count($student1Document->getAttribute('classes')));
+        $this->assertEquals(1, \count($student1Document->getDocuments('classes')));
 
         // Create document with relationship with related ID
         $database->createDocument('classes', new Document([
@@ -430,7 +446,7 @@ public function testManyToManyTwoWayRelationship(): void
             ],
             'name' => 'Student 2',
             'classes' => [
-                'class2'
+                'class2',
             ],
         ]));
 
@@ -453,7 +469,7 @@ public function testManyToManyTwoWayRelationship(): void
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Student 3',
-                ]
+                ],
             ],
         ]));
         $database->createDocument('students', new Document([
@@ -463,7 +479,7 @@ public function testManyToManyTwoWayRelationship(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Student 4'
+            'name' => 'Student 4',
         ]));
         $database->createDocument('classes', new Document([
             '$id' => 'class4',
@@ -476,70 +492,82 @@ public function testManyToManyTwoWayRelationship(): void
             'name' => 'Class 4',
             'number' => 4,
             'students' => [
-                'student4'
+                'student4',
             ],
         ]));
 
         // Get document with relationship
         $student = $database->getDocument('students', 'student1');
-        $classes = $student->getAttribute('classes', []);
-        $this->assertEquals('class1', $classes[0]['$id']);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('class1', $classes[0]->getId());
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student2');
-        $classes = $student->getAttribute('classes', []);
-        $this->assertEquals('class2', $classes[0]['$id']);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('class2', $classes[0]->getId());
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student3');
-        $classes = $student->getAttribute('classes', []);
-        $this->assertEquals('class3', $classes[0]['$id']);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('class3', $classes[0]->getId());
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student4');
-        $classes = $student->getAttribute('classes', []);
-        $this->assertEquals('class4', $classes[0]['$id']);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('class4', $classes[0]->getId());
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         // Get related document
         $class = $database->getDocument('classes', 'class1');
-        $student = $class->getAttribute('students');
-        $this->assertEquals('student1', $student[0]['$id']);
-        $this->assertArrayNotHasKey('classes', $student[0]);
+        $students = $class->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('student1', $students[0]->getId());
+        $this->assertArrayNotHasKey('classes', $students[0]);
 
         $class = $database->getDocument('classes', 'class2');
-        $student = $class->getAttribute('students');
-        $this->assertEquals('student2', $student[0]['$id']);
-        $this->assertArrayNotHasKey('classes', $student[0]);
+        $students = $class->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('student2', $students[0]->getId());
+        $this->assertArrayNotHasKey('classes', $students[0]);
 
         $class = $database->getDocument('classes', 'class3');
-        $student = $class->getAttribute('students');
-        $this->assertEquals('student3', $student[0]['$id']);
-        $this->assertArrayNotHasKey('classes', $student[0]);
+        $students = $class->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('student3', $students[0]->getId());
+        $this->assertArrayNotHasKey('classes', $students[0]);
 
         $class = $database->getDocument('classes', 'class4');
-        $student = $class->getAttribute('students');
-        $this->assertEquals('student4', $student[0]['$id']);
-        $this->assertArrayNotHasKey('classes', $student[0]);
+        $students = $class->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('student4', $students[0]->getId());
+        $this->assertArrayNotHasKey('classes', $students[0]);
 
         // Select related document attributes
         $student = $database->findOne('students', [
-            Query::select(['*', 'classes.name'])
+            Query::select(['*', 'classes.name']),
         ]);
 
         if ($student->isEmpty()) {
             throw new Exception('Student not found');
         }
 
-        $this->assertEquals('Class 1', $student->getAttribute('classes')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('number', $student->getAttribute('classes')[0]);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 1', $classes[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('number', $classes[0]);
 
         $student = $database->getDocument('students', 'student1', [
-            Query::select(['*', 'classes.name'])
+            Query::select(['*', 'classes.name']),
         ]);
 
-        $this->assertEquals('Class 1', $student->getAttribute('classes')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('number', $student->getAttribute('classes')[0]);
+        $classes = $student->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 1', $classes[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('number', $classes[0]);
 
         // Update root document attribute without altering relationship
         $student1 = $database->updateDocument(
@@ -565,7 +593,8 @@ public function testManyToManyTwoWayRelationship(): void
         $this->assertEquals('Class 2 Updated', $class2->getAttribute('name'));
 
         // Update nested document attribute
-        $classes = $student1->getAttribute('classes', []);
+        $classes = $student1->getDocuments('classes');
+        $this->assertNotEmpty($classes);
         $classes[0]->setAttribute('name', 'Class 1 Updated');
 
         $student1 = $database->updateDocument(
@@ -574,12 +603,17 @@ public function testManyToManyTwoWayRelationship(): void
             $student1->setAttribute('classes', $classes)
         );
 
-        $this->assertEquals('Class 1 Updated', $student1->getAttribute('classes')[0]->getAttribute('name'));
+        $classes = $student1->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 1 Updated', $classes[0]->getAttribute('name'));
         $student1 = $database->getDocument('students', 'student1');
-        $this->assertEquals('Class 1 Updated', $student1->getAttribute('classes')[0]->getAttribute('name'));
+        $classes = $student1->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 1 Updated', $classes[0]->getAttribute('name'));
 
         // Update inverse nested document attribute
-        $students = $class2->getAttribute('students', []);
+        $students = $class2->getDocuments('students');
+        $this->assertNotEmpty($students);
         $students[0]->setAttribute('name', 'Student 2 Updated');
 
         $class2 = $database->updateDocument(
@@ -588,9 +622,13 @@ public function testManyToManyTwoWayRelationship(): void
             $class2->setAttribute('students', $students)
         );
 
-        $this->assertEquals('Student 2 Updated', $class2->getAttribute('students')[0]->getAttribute('name'));
+        $students = $class2->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('Student 2 Updated', $students[0]->getAttribute('name'));
         $class2 = $database->getDocument('classes', 'class2');
-        $this->assertEquals('Student 2 Updated', $class2->getAttribute('students')[0]->getAttribute('name'));
+        $students = $class2->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('Student 2 Updated', $students[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $student5 = $database->createDocument('students', new Document([
@@ -619,9 +657,13 @@ public function testManyToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Class 5', $student5->getAttribute('classes')[0]->getAttribute('name'));
+        $classes = $student5->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 5', $classes[0]->getAttribute('name'));
         $student5 = $database->getDocument('students', 'student5');
-        $this->assertEquals('Class 5', $student5->getAttribute('classes')[0]->getAttribute('name'));
+        $classes = $student5->getDocuments('classes');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('Class 5', $classes[0]->getAttribute('name'));
 
         // Create child document with no relationship
         $class6 = $database->createDocument('classes', new Document([
@@ -650,9 +692,13 @@ public function testManyToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Student 6', $class6->getAttribute('students')[0]->getAttribute('name'));
+        $students = $class6->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('Student 6', $students[0]->getAttribute('name'));
         $class6 = $database->getDocument('classes', 'class6');
-        $this->assertEquals('Student 6', $class6->getAttribute('students')[0]->getAttribute('name'));
+        $students = $class6->getDocuments('students');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('Student 6', $students[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -679,14 +725,16 @@ public function testManyToManyTwoWayRelationship(): void
         );
 
         // Get document with new relationship key
-        $students = $database->getDocument('students', 'student1');
-        $classes = $students->getAttribute('newClasses');
-        $this->assertEquals('class2', $classes[0]['$id']);
+        $student = $database->getDocument('students', 'student1');
+        $classes = $student->getDocuments('newClasses');
+        $this->assertNotEmpty($classes);
+        $this->assertEquals('class2', $classes[0]->getId());
 
         // Get inverse document with new relationship key
         $class = $database->getDocument('classes', 'class1');
-        $students = $class->getAttribute('newStudents');
-        $this->assertEquals('student1', $students[0]['$id']);
+        $students = $class->getDocuments('newStudents');
+        $this->assertNotEmpty($students);
+        $this->assertEquals('student1', $students[0]->getId());
 
         // Create new document with no relationship
         $database->createDocument('students', new Document([
@@ -718,7 +766,7 @@ public function testManyToManyTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'students',
             id: 'newClasses',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         $student1 = $database->getDocument('students', 'student1');
@@ -735,13 +783,13 @@ public function testManyToManyTwoWayRelationship(): void
 
         // Check relation was set to null
         $student1 = $database->getDocument('students', 'student1');
-        $this->assertEquals(0, \count($student1->getAttribute('newClasses')));
+        $this->assertEquals(0, \count($student1->getDocuments('newClasses')));
 
         // Change on delete to cascade
         $database->updateRelationship(
             collection: 'students',
             id: 'newClasses',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -784,33 +832,28 @@ public function testNestedManyToMany_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('stones');
-        $database->createCollection('hearths');
-        $database->createCollection('plots');
+        $database->createCollection(new Collection(id: 'stones'));
+        $database->createCollection(new Collection(id: 'hearths'));
+        $database->createCollection(new Collection(id: 'plots'));
 
-        $database->createAttribute('stones', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('hearths', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('plots', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('stones', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('hearths', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('plots', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'stones',
-            relatedCollection: 'hearths',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(collection: 'stones', relatedCollection: 'hearths', twoWay: true));
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'hearths',
             relatedCollection: 'plots',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'plot',
+            key: 'plot',
             twoWayKey: 'hearth'
-        );
+        ));
 
         $database->createDocument('stones', new Document([
             '$id' => 'stone1',
@@ -851,13 +894,14 @@ public function testNestedManyToMany_OneToOneRelationship(): void
         ]));
 
         $stone1 = $database->getDocument('stones', 'stone1');
-        $this->assertEquals(2, \count($stone1['hearths']));
-        $this->assertEquals('hearth1', $stone1['hearths'][0]['$id']);
-        $this->assertEquals('hearth2', $stone1['hearths'][1]['$id']);
-        $this->assertArrayNotHasKey('stone', $stone1['hearths'][0]);
-        $this->assertEquals('plot1', $stone1['hearths'][0]['plot']['$id']);
-        $this->assertEquals('plot2', $stone1['hearths'][1]['plot']['$id']);
-        $this->assertArrayNotHasKey('hearth', $stone1['hearths'][0]['plot']);
+        $hearths = $stone1->getDocuments('hearths');
+        $this->assertCount(2, $hearths);
+        $this->assertEquals('hearth1', $hearths[0]->getId());
+        $this->assertEquals('hearth2', $hearths[1]->getId());
+        $this->assertArrayNotHasKey('stone', $hearths[0]);
+        $this->assertEquals('plot1', $hearths[0]->getDocument('plot')->getId());
+        $this->assertEquals('plot2', $hearths[1]->getDocument('plot')->getId());
+        $this->assertArrayNotHasKey('hearth', $hearths[0]->getDocument('plot'));
 
         $database->createDocument('plots', new Document([
             '$id' => 'plot3',
@@ -884,10 +928,13 @@ public function testNestedManyToMany_OneToOneRelationship(): void
         ]));
 
         $plot3 = $database->getDocument('plots', 'plot3');
-        $this->assertEquals('hearth3', $plot3['hearth']['$id']);
-        $this->assertArrayNotHasKey('plot', $plot3['hearth']);
-        $this->assertEquals('stone2', $plot3['hearth']['stones'][0]['$id']);
-        $this->assertArrayNotHasKey('hearths', $plot3['hearth']['stones'][0]);
+        $hearth = $plot3->getDocument('hearth');
+        $this->assertEquals('hearth3', $hearth->getId());
+        $this->assertArrayNotHasKey('plot', $hearth);
+        $stones = $hearth->getDocuments('stones');
+        $this->assertNotEmpty($stones);
+        $this->assertEquals('stone2', $stones[0]->getId());
+        $this->assertArrayNotHasKey('hearths', $stones[0]);
     }
 
     public function testNestedManyToMany_OneToManyRelationship(): void
@@ -895,33 +942,28 @@ public function testNestedManyToMany_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('groups');
-        $database->createCollection('tounaments');
-        $database->createCollection('prizes');
+        $database->createCollection(new Collection(id: 'groups'));
+        $database->createCollection(new Collection(id: 'tounaments'));
+        $database->createCollection(new Collection(id: 'prizes'));
 
-        $database->createAttribute('groups', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tounaments', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('prizes', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('groups', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('tounaments', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('prizes', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'groups',
-            relatedCollection: 'tounaments',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(collection: 'groups', relatedCollection: 'tounaments', twoWay: true));
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'tounaments',
             relatedCollection: 'prizes',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'prizes',
+            key: 'prizes',
             twoWayKey: 'tounament'
-        );
+        ));
 
         $database->createDocument('groups', new Document([
             '$id' => 'group1',
@@ -980,14 +1022,16 @@ public function testNestedManyToMany_OneToManyRelationship(): void
         ]));
 
         $group1 = $database->getDocument('groups', 'group1');
-        $this->assertEquals(2, \count($group1['tounaments']));
-        $this->assertEquals('tounament1', $group1['tounaments'][0]['$id']);
-        $this->assertEquals('tounament2', $group1['tounaments'][1]['$id']);
-        $this->assertArrayNotHasKey('group', $group1['tounaments'][0]);
-        $this->assertEquals(2, \count($group1['tounaments'][0]['prizes']));
-        $this->assertEquals('prize1', $group1['tounaments'][0]['prizes'][0]['$id']);
-        $this->assertEquals('prize2', $group1['tounaments'][0]['prizes'][1]['$id']);
-        $this->assertArrayNotHasKey('tounament', $group1['tounaments'][0]['prizes'][0]);
+        $tounaments = $group1->getDocuments('tounaments');
+        $this->assertCount(2, $tounaments);
+        $this->assertEquals('tounament1', $tounaments[0]->getId());
+        $this->assertEquals('tounament2', $tounaments[1]->getId());
+        $this->assertArrayNotHasKey('group', $tounaments[0]);
+        $prizes = $tounaments[0]->getDocuments('prizes');
+        $this->assertCount(2, $prizes);
+        $this->assertEquals('prize1', $prizes[0]->getId());
+        $this->assertEquals('prize2', $prizes[1]->getId());
+        $this->assertArrayNotHasKey('tounament', $prizes[0]);
     }
 
     public function testNestedManyToMany_ManyToOneRelationship(): void
@@ -995,33 +1039,28 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('platforms');
-        $database->createCollection('games');
-        $database->createCollection('publishers');
+        $database->createCollection(new Collection(id: 'platforms'));
+        $database->createCollection(new Collection(id: 'games'));
+        $database->createCollection(new Collection(id: 'publishers'));
 
-        $database->createAttribute('platforms', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('games', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('publishers', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('platforms', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('games', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('publishers', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'platforms',
-            relatedCollection: 'games',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(collection: 'platforms', relatedCollection: 'games', twoWay: true));
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'games',
             relatedCollection: 'publishers',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'publisher',
+            key: 'publisher',
             twoWayKey: 'games'
-        );
+        ));
 
         $database->createDocument('platforms', new Document([
             '$id' => 'platform1',
@@ -1058,17 +1097,18 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
                         'name' => 'Publisher 2',
                     ],
                 ],
-            ]
+            ],
         ]));
 
         $platform1 = $database->getDocument('platforms', 'platform1');
-        $this->assertEquals(2, \count($platform1['games']));
-        $this->assertEquals('game1', $platform1['games'][0]['$id']);
-        $this->assertEquals('game2', $platform1['games'][1]['$id']);
-        $this->assertArrayNotHasKey('platforms', $platform1['games'][0]);
-        $this->assertEquals('publisher1', $platform1['games'][0]['publisher']['$id']);
-        $this->assertEquals('publisher2', $platform1['games'][1]['publisher']['$id']);
-        $this->assertArrayNotHasKey('games', $platform1['games'][0]['publisher']);
+        $games = $platform1->getDocuments('games');
+        $this->assertCount(2, $games);
+        $this->assertEquals('game1', $games[0]->getId());
+        $this->assertEquals('game2', $games[1]->getId());
+        $this->assertArrayNotHasKey('platforms', $games[0]);
+        $this->assertEquals('publisher1', $games[0]->getDocument('publisher')->getId());
+        $this->assertEquals('publisher2', $games[1]->getDocument('publisher')->getId());
+        $this->assertArrayNotHasKey('games', $games[0]->getDocument('publisher'));
 
         $database->createDocument('publishers', new Document([
             '$id' => 'publisher3',
@@ -1090,18 +1130,21 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
                                 Permission::read(Role::any()),
                             ],
                             'name' => 'Platform 2',
-                        ]
+                        ],
                     ],
                 ],
             ],
         ]));
 
         $publisher3 = $database->getDocument('publishers', 'publisher3');
-        $this->assertEquals(1, \count($publisher3['games']));
-        $this->assertEquals('game3', $publisher3['games'][0]['$id']);
-        $this->assertArrayNotHasKey('publisher', $publisher3['games'][0]);
-        $this->assertEquals('platform2', $publisher3['games'][0]['platforms'][0]['$id']);
-        $this->assertArrayNotHasKey('games', $publisher3['games'][0]['platforms'][0]);
+        $games = $publisher3->getDocuments('games');
+        $this->assertCount(1, $games);
+        $this->assertEquals('game3', $games[0]->getId());
+        $this->assertArrayNotHasKey('publisher', $games[0]);
+        $platforms = $games[0]->getDocuments('platforms');
+        $this->assertNotEmpty($platforms);
+        $this->assertEquals('platform2', $platforms[0]->getId());
+        $this->assertArrayNotHasKey('games', $platforms[0]);
     }
 
     public function testNestedManyToMany_ManyToManyRelationship(): void
@@ -1109,33 +1152,28 @@ public function testNestedManyToMany_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('sauces');
-        $database->createCollection('pizzas');
-        $database->createCollection('toppings');
+        $database->createCollection(new Collection(id: 'sauces'));
+        $database->createCollection(new Collection(id: 'pizzas'));
+        $database->createCollection(new Collection(id: 'toppings'));
 
-        $database->createAttribute('sauces', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('pizzas', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('toppings', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('sauces', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('pizzas', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('toppings', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'sauces',
-            relatedCollection: 'pizzas',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(collection: 'sauces', relatedCollection: 'pizzas', twoWay: true));
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'pizzas',
             relatedCollection: 'toppings',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'toppings',
+            key: 'toppings',
             twoWayKey: 'pizzas'
-        );
+        ));
 
         $database->createDocument('sauces', new Document([
             '$id' => 'sauce1',
@@ -1190,22 +1228,25 @@ public function testNestedManyToMany_ManyToManyRelationship(): void
                         ],
                     ],
                 ],
-            ]
+            ],
         ]));
 
         $sauce1 = $database->getDocument('sauces', 'sauce1');
-        $this->assertEquals(2, \count($sauce1['pizzas']));
-        $this->assertEquals('pizza1', $sauce1['pizzas'][0]['$id']);
-        $this->assertEquals('pizza2', $sauce1['pizzas'][1]['$id']);
-        $this->assertArrayNotHasKey('sauces', $sauce1['pizzas'][0]);
-        $this->assertEquals(2, \count($sauce1['pizzas'][0]['toppings']));
-        $this->assertEquals('topping1', $sauce1['pizzas'][0]['toppings'][0]['$id']);
-        $this->assertEquals('topping2', $sauce1['pizzas'][0]['toppings'][1]['$id']);
-        $this->assertArrayNotHasKey('pizzas', $sauce1['pizzas'][0]['toppings'][0]);
-        $this->assertEquals(2, \count($sauce1['pizzas'][1]['toppings']));
-        $this->assertEquals('topping3', $sauce1['pizzas'][1]['toppings'][0]['$id']);
-        $this->assertEquals('topping4', $sauce1['pizzas'][1]['toppings'][1]['$id']);
-        $this->assertArrayNotHasKey('pizzas', $sauce1['pizzas'][1]['toppings'][0]);
+        $pizzas = $sauce1->getDocuments('pizzas');
+        $this->assertCount(2, $pizzas);
+        $this->assertEquals('pizza1', $pizzas[0]->getId());
+        $this->assertEquals('pizza2', $pizzas[1]->getId());
+        $this->assertArrayNotHasKey('sauces', $pizzas[0]);
+        $pizza1Toppings = $pizzas[0]->getDocuments('toppings');
+        $this->assertCount(2, $pizza1Toppings);
+        $this->assertEquals('topping1', $pizza1Toppings[0]->getId());
+        $this->assertEquals('topping2', $pizza1Toppings[1]->getId());
+        $this->assertArrayNotHasKey('pizzas', $pizza1Toppings[0]);
+        $pizza2Toppings = $pizzas[1]->getDocuments('toppings');
+        $this->assertCount(2, $pizza2Toppings);
+        $this->assertEquals('topping3', $pizza2Toppings[0]->getId());
+        $this->assertEquals('topping4', $pizza2Toppings[1]->getId());
+        $this->assertArrayNotHasKey('pizzas', $pizza2Toppings[0]);
     }
 
     public function testManyToManyRelationshipKeyWithSymbols(): void
@@ -1213,42 +1254,42 @@ public function testManyToManyRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('$symbols_coll.ection7');
-        $database->createCollection('$symbols_coll.ection8');
+        $database->createCollection(new Collection(id: '$symbols_coll.ection7'));
+        $database->createCollection(new Collection(id: '$symbols_coll.ection8'));
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection7',
-            relatedCollection: '$symbols_coll.ection8',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: '$symbols_coll.ection7', relatedCollection: '$symbols_coll.ection8', twoWay: true));
 
         $doc1 = $database->createDocument('$symbols_coll.ection8', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
         $doc2 = $database->createDocument('$symbols_coll.ection7', new Document([
             '$id' => ID::unique(),
-            '$symbols_coll.ection8' => [$doc1->getId()],
+            'symbols_collection8' => [$doc1->getId()],
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
 
         $doc1 = $database->getDocument('$symbols_coll.ection8', $doc1->getId());
         $doc2 = $database->getDocument('$symbols_coll.ection7', $doc2->getId());
 
-        $this->assertEquals($doc2->getId(), $doc1->getAttribute('$symbols_coll.ection7')[0]->getId());
-        $this->assertEquals($doc1->getId(), $doc2->getAttribute('$symbols_coll.ection8')[0]->getId());
+        $relatedFromDoc1 = $doc1->getDocuments('symbols_collection7');
+        $this->assertNotEmpty($relatedFromDoc1);
+        $this->assertEquals($doc2->getId(), $relatedFromDoc1[0]->getId());
+        $relatedFromDoc2 = $doc2->getDocuments('symbols_collection8');
+        $this->assertNotEmpty($relatedFromDoc2);
+        $this->assertEquals($doc1->getId(), $relatedFromDoc2[0]->getId());
     }
 
     public function testRecreateManyToManyOneWayRelationshipFromChild(): void
@@ -1256,65 +1297,42 @@ public function testRecreateManyToManyOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $result = $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyTwoWayRelationshipFromParent(): void
@@ -1322,67 +1340,42 @@ public function testRecreateManyToManyTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyTwoWayRelationshipFromChild(): void
@@ -1390,67 +1383,42 @@ public function testRecreateManyToManyTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyOneWayRelationshipFromParent(): void
@@ -1458,65 +1426,42 @@ public function testRecreateManyToManyOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $result = $database->createRelationship(Relationship::manyToMany(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testSelectManyToMany(): void
@@ -1524,26 +1469,22 @@ public function testSelectManyToMany(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('select_m2m_collection1');
-        $database->createCollection('select_m2m_collection2');
+        $database->createCollection(new Collection(id: 'select_m2m_collection1'));
+        $database->createCollection(new Collection(id: 'select_m2m_collection2'));
 
-        $database->createAttribute('select_m2m_collection1', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('select_m2m_collection1', 'type', Database::VAR_STRING, 255, true);
-        $database->createAttribute('select_m2m_collection2', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('select_m2m_collection2', 'type', Database::VAR_STRING, 255, true);
+        $database->createAttribute('select_m2m_collection1', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('select_m2m_collection1', Attribute::string(key: 'type', required: true));
+        $database->createAttribute('select_m2m_collection2', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('select_m2m_collection2', Attribute::string(key: 'type', required: true));
 
         // Many-to-Many Relationship
-        $database->createRelationship(
-            collection: 'select_m2m_collection1',
-            relatedCollection: 'select_m2m_collection2',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: 'select_m2m_collection1', relatedCollection: 'select_m2m_collection2', twoWay: true));
 
         // Create documents in the first collection
         $doc1 = $database->createDocument('select_m2m_collection1', new Document([
@@ -1588,7 +1529,7 @@ public function testSelectManyToMany(): void
         $this->assertEquals('Document 1', $docs[0]->getAttribute('name'));
         $this->assertArrayNotHasKey('type', $docs[0]);
 
-        $relatedDocs = $docs[0]->getAttribute('select_m2m_collection2');
+        $relatedDocs = $docs[0]->getDocuments('select_m2m_collection2');
 
         $this->assertCount(2, $relatedDocs);
         $this->assertEquals('Related Document 1', $relatedDocs[0]->getAttribute('name'));
@@ -1602,51 +1543,42 @@ public function testSelectAcrossMultipleCollections(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create collections
-        $database->createCollection('artists', permissions: [
+        $database->createCollection(new Collection(id: 'artists', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: false);
-        $database->createCollection('albums', permissions: [
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
+        $database->createCollection(new Collection(id: 'albums', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: false);
-        $database->createCollection('tracks', permissions: [
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
+        $database->createCollection(new Collection(id: 'tracks', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ], documentSecurity: false);
+            Permission::delete(Role::any()),
+        ], documentSecurity: false));
 
         // Add attributes
-        $database->createAttribute('artists', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('albums', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tracks', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tracks', 'duration', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('artists', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('albums', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('tracks', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('tracks', Attribute::integer(key: 'duration', required: true));
 
         // Create relationships
-        $database->createRelationship(
-            collection: 'artists',
-            relatedCollection: 'albums',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: 'artists', relatedCollection: 'albums', twoWay: true));
 
-        $database->createRelationship(
-            collection: 'albums',
-            relatedCollection: 'tracks',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: 'albums', relatedCollection: 'tracks', twoWay: true));
 
         // Create documents
         $database->createDocument('artists', new Document([
@@ -1666,8 +1598,8 @@ public function testSelectAcrossMultipleCollections(): void
                             '$id' => 'track2',
                             'title' => 'Hit Song 2',
                             'duration' => 220,
-                        ]
-                    ]
+                        ],
+                    ],
                 ],
                 [
                     '$id' => 'album2',
@@ -1677,15 +1609,15 @@ public function testSelectAcrossMultipleCollections(): void
                             '$id' => 'track3',
                             'title' => 'Ballad 3',
                             'duration' => 240,
-                        ]
-                    ]
-                ]
-            ]
+                        ],
+                    ],
+                ],
+            ],
         ]));
 
         // Query with nested select
         $artists = $database->find('artists', [
-            Query::select(['name', 'albums.name', 'albums.tracks.title'])
+            Query::select(['name', 'albums.name', 'albums.tracks.title']),
         ]);
 
         $this->assertCount(1, $artists);
@@ -1693,29 +1625,29 @@ public function testSelectAcrossMultipleCollections(): void
         $this->assertEquals('The Great Artist', $artist->getAttribute('name'));
         $this->assertArrayHasKey('albums', $artist->getArrayCopy());
 
-        $albums = $artist->getAttribute('albums');
+        $albums = $artist->getDocuments('albums');
         $this->assertCount(2, $albums);
 
         $album1 = $albums[0];
         $this->assertEquals('First Album', $album1->getAttribute('name'));
-        $this->assertArrayHasKey('tracks', $album1->getArrayCopy());
-        $this->assertArrayNotHasKey('artists', $album1->getArrayCopy());
+        $this->assertArrayHasKey('tracks', $album1);
+        $this->assertArrayNotHasKey('artists', $album1);
 
         $album2 = $albums[1];
         $this->assertEquals('Second Album', $album2->getAttribute('name'));
-        $this->assertArrayHasKey('tracks', $album2->getArrayCopy());
+        $this->assertArrayHasKey('tracks', $album2);
 
-        $album1Tracks = $album1->getAttribute('tracks');
+        $album1Tracks = $album1->getDocuments('tracks');
         $this->assertCount(2, $album1Tracks);
         $this->assertEquals('Hit Song 1', $album1Tracks[0]->getAttribute('title'));
-        $this->assertArrayNotHasKey('duration', $album1Tracks[0]->getArrayCopy());
+        $this->assertArrayNotHasKey('duration', $album1Tracks[0]);
         $this->assertEquals('Hit Song 2', $album1Tracks[1]->getAttribute('title'));
-        $this->assertArrayNotHasKey('duration', $album1Tracks[1]->getArrayCopy());
+        $this->assertArrayNotHasKey('duration', $album1Tracks[1]);
 
-        $album2Tracks = $album2->getAttribute('tracks');
+        $album2Tracks = $album2->getDocuments('tracks');
         $this->assertCount(1, $album2Tracks);
         $this->assertEquals('Ballad 3', $album2Tracks[0]->getAttribute('title'));
-        $this->assertArrayNotHasKey('duration', $album2Tracks[0]->getArrayCopy());
+        $this->assertArrayNotHasKey('duration', $album2Tracks[0]);
     }
 
     public function testDeleteBulkDocumentsManyToManyRelationship(): void
@@ -1723,25 +1655,21 @@ public function testDeleteBulkDocumentsManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->createCollection('bulk_delete_person_m2m');
-        $this->getDatabase()->createCollection('bulk_delete_library_m2m');
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_person_m2m'));
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_library_m2m'));
 
-        $this->getDatabase()->createAttribute('bulk_delete_person_m2m', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', 'area', Database::VAR_STRING, 255, true);
+        $this->getDatabase()->createAttribute('bulk_delete_person_m2m', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', Attribute::string(key: 'area', required: true));
 
         // Many-to-Many Relationship
-        $this->getDatabase()->createRelationship(
-            collection: 'bulk_delete_person_m2m',
-            relatedCollection: 'bulk_delete_library_m2m',
-            type: Database::RELATION_MANY_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $this->getDatabase()->createRelationship(Relationship::manyToMany(collection: 'bulk_delete_person_m2m', relatedCollection: 'bulk_delete_library_m2m'));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_m2m', new Document([
             '$id' => 'person1',
@@ -1776,7 +1704,7 @@ public function testDeleteBulkDocumentsManyToManyRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_m2m', 'person1');
-        $libraries = $person1->getAttribute('bulk_delete_library_m2m');
+        $libraries = $person1->getDocuments('bulk_delete_library_m2m');
         $this->assertCount(2, $libraries);
 
         // Delete person
@@ -1795,36 +1723,32 @@ public function testDeleteBulkDocumentsManyToManyRelationship(): void
         $this->getDatabase()->deleteDocuments('bulk_delete_person_m2m');
         $this->assertCount(0, $this->getDatabase()->find('bulk_delete_person_m2m'));
     }
+
     public function testUpdateParentAndChild_ManyToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
         if (
-            !$database->getAdapter()->getSupportForRelationships() ||
-            !$database->getAdapter()->getSupportForBatchOperations()
+            ! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_combined_m2m';
         $childCollection = 'child_combined_m2m';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
-
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'parentNumber', Database::VAR_INTEGER, 0, false);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
 
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::integer(key: 'parentNumber'));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_MANY_TO_MANY,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $parentCollection, relatedCollection: $childCollection, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1879,31 +1803,26 @@ public function testUpdateParentAndChild_ManyToMany(): void
         $database->deleteCollection($childCollection);
     }
 
-
     public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_relationship_many_to_many';
         $childCollection = 'child_relationship_many_to_many';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_MANY_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createRelationship(Relationship::manyToMany(collection: $parentCollection, relatedCollection: $childCollection));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1922,8 +1841,8 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToMa
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Child 1',
-                ]
-            ]
+                ],
+            ],
         ]));
 
         try {
@@ -1945,27 +1864,27 @@ public function testPartialUpdateManyToManyBothSides(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('partial_students');
-        $database->createCollection('partial_courses');
+        $database->createCollection(new Collection(id: 'partial_students'));
+        $database->createCollection(new Collection(id: 'partial_courses'));
 
-        $database->createAttribute('partial_students', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('partial_students', 'grade', Database::VAR_STRING, 10, false);
-        $database->createAttribute('partial_courses', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('partial_courses', 'credits', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute('partial_students', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('partial_students', Attribute::string(key: 'grade', size: 10));
+        $database->createAttribute('partial_courses', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('partial_courses', Attribute::integer(key: 'credits'));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'partial_students',
             relatedCollection: 'partial_courses',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'partial_courses',
+            key: 'partial_courses',
             twoWayKey: 'partial_students'
-        );
+        ));
 
         // Create student with courses
         $database->createDocument('partial_students', new Document([
@@ -1990,7 +1909,7 @@ public function testPartialUpdateManyToManyBothSides(): void
         $student = $database->getDocument('partial_students', 'student1');
         $this->assertEquals('David', $student->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals('A+', $student->getAttribute('grade'), 'Grade should be updated');
-        $this->assertCount(2, $student->getAttribute('partial_courses'), 'Courses should be preserved');
+        $this->assertCount(2, $student->getDocuments('partial_courses'), 'Courses should be preserved');
 
         // Partial update from course side - update credits only, preserve students
         $database->updateDocument('partial_courses', 'course1', new Document([
@@ -2003,7 +1922,7 @@ public function testPartialUpdateManyToManyBothSides(): void
         $course = $database->getDocument('partial_courses', 'course1');
         $this->assertEquals('Math', $course->getAttribute('title'), 'Title should be preserved');
         $this->assertEquals(5, $course->getAttribute('credits'), 'Credits should be updated');
-        $this->assertCount(1, $course->getAttribute('partial_students'), 'Students should be preserved');
+        $this->assertCount(1, $course->getDocuments('partial_students'), 'Students should be preserved');
 
         $database->deleteCollection('partial_students');
         $database->deleteCollection('partial_courses');
@@ -2014,27 +1933,27 @@ public function testPartialUpdateManyToManyWithStringIdsAndDocuments(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('tags');
-        $database->createCollection('articles');
+        $database->createCollection(new Collection(id: 'tags'));
+        $database->createCollection(new Collection(id: 'articles'));
 
-        $database->createAttribute('tags', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tags', 'color', Database::VAR_STRING, 50, false);
-        $database->createAttribute('articles', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('articles', 'published', Database::VAR_BOOLEAN, 0, false);
+        $database->createAttribute('tags', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('tags', Attribute::string(key: 'color', size: 50));
+        $database->createAttribute('articles', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('articles', Attribute::boolean(key: 'published'));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'articles',
             relatedCollection: 'tags',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'tags',
+            key: 'tags',
             twoWayKey: 'articles'
-        );
+        ));
 
         // Create article with tags
         $database->createDocument('articles', new Document([
@@ -2065,7 +1984,7 @@ public function testPartialUpdateManyToManyWithStringIdsAndDocuments(): void
         $article = $database->getDocument('articles', 'article1');
         $this->assertEquals('Great Article', $article->getAttribute('title'));
         $this->assertFalse($article->getAttribute('published'));
-        $this->assertCount(2, $article->getAttribute('tags'));
+        $this->assertCount(2, $article->getDocuments('tags'));
 
         // Update from tag side using DOCUMENT objects
         $database->createDocument('articles', new Document([
@@ -2088,169 +2007,12 @@ public function testPartialUpdateManyToManyWithStringIdsAndDocuments(): void
         $tag = $database->getDocument('tags', 'tag1');
         $this->assertEquals('Tech', $tag->getAttribute('name'));
         $this->assertEquals('blue', $tag->getAttribute('color'));
-        $this->assertCount(2, $tag->getAttribute('articles'));
+        $this->assertCount(2, $tag->getDocuments('articles'));
 
         $database->deleteCollection('tags');
         $database->deleteCollection('articles');
     }
 
-    public function testManyToManyRelationshipWithArrayOperators(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if (!$database->getAdapter()->getSupportForOperators()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Cleanup any leftover collections from previous runs
-        try {
-            $database->deleteCollection('library');
-        } catch (\Throwable $e) {
-        }
-        try {
-            $database->deleteCollection('book');
-        } catch (\Throwable $e) {
-        }
-
-        $database->createCollection('library');
-        $database->createCollection('book');
-
-        $database->createAttribute('library', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('book', 'title', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'library',
-            relatedCollection: 'book',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'books',
-            twoWayKey: 'libraries'
-        );
-
-        // Create some books
-        $book1 = $database->createDocument('book', new Document([
-            '$id' => 'book1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Book 1',
-        ]));
-
-        $book2 = $database->createDocument('book', new Document([
-            '$id' => 'book2',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Book 2',
-        ]));
-
-        $book3 = $database->createDocument('book', new Document([
-            '$id' => 'book3',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Book 3',
-        ]));
-
-        $book4 = $database->createDocument('book', new Document([
-            '$id' => 'book4',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Book 4',
-        ]));
-
-        // Create library with one book
-        $library = $database->createDocument('library', new Document([
-            '$id' => 'library1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'Library 1',
-            'books' => ['book1'],
-        ]));
-
-        $this->assertCount(1, $library->getAttribute('books'));
-        $this->assertEquals('book1', $library->getAttribute('books')[0]->getId());
-
-        // Test arrayAppend - add a single book
-        $library = $database->updateDocument('library', 'library1', new Document([
-            'books' => \Utopia\Database\Operator::arrayAppend(['book2']),
-        ]));
-
-        $library = $database->getDocument('library', 'library1');
-        $this->assertCount(2, $library->getAttribute('books'));
-        $bookIds = \array_map(fn ($book) => $book->getId(), $library->getAttribute('books'));
-        $this->assertContains('book1', $bookIds);
-        $this->assertContains('book2', $bookIds);
-
-        // Test arrayAppend - add multiple books
-        $library = $database->updateDocument('library', 'library1', new Document([
-            'books' => \Utopia\Database\Operator::arrayAppend(['book3', 'book4']),
-        ]));
-
-        $library = $database->getDocument('library', 'library1');
-        $this->assertCount(4, $library->getAttribute('books'));
-        $bookIds = \array_map(fn ($book) => $book->getId(), $library->getAttribute('books'));
-        $this->assertContains('book1', $bookIds);
-        $this->assertContains('book2', $bookIds);
-        $this->assertContains('book3', $bookIds);
-        $this->assertContains('book4', $bookIds);
-
-        // Test arrayRemove - remove a single book
-        $library = $database->updateDocument('library', 'library1', new Document([
-            'books' => \Utopia\Database\Operator::arrayRemove('book2'),
-        ]));
-
-        $library = $database->getDocument('library', 'library1');
-        $this->assertCount(3, $library->getAttribute('books'));
-        $bookIds = \array_map(fn ($book) => $book->getId(), $library->getAttribute('books'));
-        $this->assertContains('book1', $bookIds);
-        $this->assertNotContains('book2', $bookIds);
-        $this->assertContains('book3', $bookIds);
-        $this->assertContains('book4', $bookIds);
-
-        // Test arrayRemove - remove multiple books at once
-        $library = $database->updateDocument('library', 'library1', new Document([
-            'books' => \Utopia\Database\Operator::arrayRemove(['book3', 'book4']),
-        ]));
-
-        $library = $database->getDocument('library', 'library1');
-        $this->assertCount(1, $library->getAttribute('books'));
-        $bookIds = \array_map(fn ($book) => $book->getId(), $library->getAttribute('books'));
-        $this->assertContains('book1', $bookIds);
-        $this->assertNotContains('book3', $bookIds);
-        $this->assertNotContains('book4', $bookIds);
-
-        // Test arrayPrepend - add books
-        // Note: Order is not guaranteed for many-to-many relationships as they use junction tables
-        $library = $database->updateDocument('library', 'library1', new Document([
-            'books' => \Utopia\Database\Operator::arrayPrepend(['book2']),
-        ]));
-
-        $library = $database->getDocument('library', 'library1');
-        $this->assertCount(2, $library->getAttribute('books'));
-        $bookIds = \array_map(fn ($book) => $book->getId(), $library->getAttribute('books'));
-        $this->assertContains('book1', $bookIds);
-        $this->assertContains('book2', $bookIds);
-
-        // Cleanup
-        $database->deleteCollection('library');
-        $database->deleteCollection('book');
-    }
-
     /**
      * Regression: processNestedRelationshipPath used skipRelationships()
      * for many-to-many reverse lookups, which prevented junction-table data
@@ -2261,37 +2023,44 @@ public function testNestedManyToManyRelationshipQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
+        // Clean up if collections already exist from other tests
+        foreach (['brands', 'products', 'tags'] as $col) {
+            try {
+                $database->deleteCollection($col);
+            } catch (\Throwable) {
+            }
+        }
+
         // 3-level many-to-many chain: brands <-> products <-> tags
-        $database->createCollection('brands');
-        $database->createCollection('products');
-        $database->createCollection('tags');
+        $database->createCollection(new Collection(id: 'brands'));
+        $database->createCollection(new Collection(id: 'products'));
+        $database->createCollection(new Collection(id: 'tags'));
 
-        $database->createAttribute('brands', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('products', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('tags', 'label', Database::VAR_STRING, 255, true);
+        $database->createAttribute('brands', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('products', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('tags', Attribute::string(key: 'label', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'brands',
             relatedCollection: 'products',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'products',
-            twoWayKey: 'brands',
-        );
+            key: 'products',
+            twoWayKey: 'brands'
+        ));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'products',
             relatedCollection: 'tags',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'tags',
-            twoWayKey: 'products',
-        );
+            key: 'tags',
+            twoWayKey: 'products'
+        ));
 
         // Seed data
         $database->createDocument('tags', new Document([
@@ -2342,14 +2111,14 @@ public function testNestedManyToManyRelationshipQueries(): void
             'products' => ['prod_c'],
         ]));
 
-        // --- 1-level deep: query brands by product title (many-to-many) ---
+        // 1-level deep: query brands by product title (many-to-many)
         $brands = $database->find('brands', [
             Query::equal('products.title', ['Product A']),
         ]);
         $this->assertCount(1, $brands);
         $this->assertEquals('brand_x', $brands[0]->getId());
 
-        // --- 2-level deep: query brands by product→tag label (many-to-many→many-to-many) ---
+        // 2-level deep: query brands by product→tag label (many-to-many→many-to-many)
         // "Eco-Friendly" tag is on prod_a (BrandX) and prod_c (BrandY)
         $brands = $database->find('brands', [
             Query::equal('products.tags.label', ['Eco-Friendly']),
@@ -2373,7 +2142,7 @@ public function testNestedManyToManyRelationshipQueries(): void
         $this->assertCount(1, $brands);
         $this->assertEquals('brand_x', $brands[0]->getId());
 
-        // --- 2-level deep from the child side: query tags by product→brand name ---
+        // 2-level deep from the child side: query tags by product→brand name
         $tags = $database->find('tags', [
             Query::equal('products.brands.name', ['BrandY']),
         ]);
@@ -2389,7 +2158,7 @@ public function testNestedManyToManyRelationshipQueries(): void
         $this->assertContains('tag_premium', $tagIds);
         $this->assertContains('tag_sale', $tagIds);
 
-        // --- No match returns empty ---
+        // No match returns empty
         $brands = $database->find('brands', [
             Query::equal('products.tags.label', ['NonExistent']),
         ]);
diff --git a/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php b/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
index e62ff735c3..b192a5d99f 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
@@ -3,6 +3,10 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +15,10 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait ManyToOneTests
 {
@@ -19,53 +27,49 @@ public function testManyToOneOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('review');
-        $database->createCollection('movie');
+        $database->createCollection(new Collection(id: 'review'));
+        $database->createCollection(new Collection(id: 'movie'));
 
-        $database->createAttribute('review', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('movie', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('movie', 'length', Database::VAR_INTEGER, 0, true, formatOptions: ['min' => 0, 'max' => 999]);
-        $database->createAttribute('movie', 'date', Database::VAR_DATETIME, 0, false, filters: ['datetime']);
-        $database->createAttribute('review', 'date', Database::VAR_DATETIME, 0, false, filters: ['datetime']);
-        $database->createRelationship(
-            collection: 'review',
-            relatedCollection: 'movie',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWayKey: 'reviews'
-        );
+        $database->createAttribute('review', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('movie', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('movie', Attribute::integer(key: 'length', required: true, formatOptions: ['min' => 0, 'max' => 999]));
+        $database->createAttribute('movie', Attribute::datetime(key: 'date', filters: ['datetime']));
+        $database->createAttribute('review', Attribute::datetime(key: 'date', filters: ['datetime']));
+        $database->createRelationship(Relationship::manyToOne(collection: 'review', relatedCollection: 'movie', twoWayKey: 'reviews'));
 
         // Check metadata for collection
         $collection = $database->getCollection('review');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'movie') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('movie', $attribute['$id']);
-                $this->assertEquals('movie', $attribute['key']);
-                $this->assertEquals('movie', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(false, $attribute['options']['twoWay']);
-                $this->assertEquals('reviews', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'movie') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('movie', $attribute->getId());
+                $this->assertEquals('movie', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('movie', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(false, $options['twoWay'] ?? null);
+                $this->assertEquals('reviews', $options['twoWayKey'] ?? null);
             }
         }
 
         // Check metadata for related collection
         $collection = $database->getCollection('movie');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'reviews') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('reviews', $attribute['$id']);
-                $this->assertEquals('reviews', $attribute['key']);
-                $this->assertEquals('review', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(false, $attribute['options']['twoWay']);
-                $this->assertEquals('movie', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'reviews') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('reviews', $attribute->getId());
+                $this->assertEquals('reviews', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('review', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(false, $options['twoWay'] ?? null);
+                $this->assertEquals('movie', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -140,12 +144,12 @@ public function testManyToOneOneWayRelationship(): void
 
         // Get document with relationship
         $review = $database->getDocument('review', 'review1');
-        $movie = $review->getAttribute('movie', []);
-        $this->assertEquals('movie1', $movie['$id']);
+        $movie = $review->getDocument('movie');
+        $this->assertEquals('movie1', $movie->getId());
         $this->assertArrayNotHasKey('reviews', $movie);
 
         $documents = $database->find('review', [
-            Query::select(['date', 'movie.date'])
+            Query::select(['date', 'movie.date']),
         ]);
 
         $this->assertCount(3, $documents);
@@ -153,14 +157,18 @@ public function testManyToOneOneWayRelationship(): void
         $document = $documents[0];
         $this->assertArrayHasKey('date', $document);
         $this->assertArrayHasKey('movie', $document);
-        $this->assertArrayHasKey('date', $document->getAttribute('movie'));
+        $this->assertArrayHasKey('date', $document->getDocument('movie'));
         $this->assertArrayNotHasKey('name', $document);
-        $this->assertEquals(29, strlen($document['date'])); // checks filter
-        $this->assertEquals(29, strlen($document['movie']['date']));
+        $date = $document->getAttribute('date');
+        $this->assertIsString($date);
+        $this->assertEquals(29, strlen($date));
+        $movieDate = $document->getDocument('movie')->getAttribute('date');
+        $this->assertIsString($movieDate);
+        $this->assertEquals(29, strlen($movieDate));
 
         $review = $database->getDocument('review', 'review2');
-        $movie = $review->getAttribute('movie', []);
-        $this->assertEquals('movie2', $movie['$id']);
+        $movie = $review->getDocument('movie');
+        $this->assertEquals('movie2', $movie->getId());
         $this->assertArrayNotHasKey('reviews', $movie);
 
         // Get related document
@@ -176,22 +184,22 @@ public function testManyToOneOneWayRelationship(): void
 
         // Select related document attributes
         $review = $database->findOne('review', [
-            Query::select(['*', 'movie.name'])
+            Query::select(['*', 'movie.name']),
         ]);
 
         if ($review->isEmpty()) {
             throw new Exception('Review not found');
         }
 
-        $this->assertEquals('Movie 1', $review->getAttribute('movie')->getAttribute('name'));
-        $this->assertArrayNotHasKey('length', $review->getAttribute('movie'));
+        $this->assertEquals('Movie 1', $review->getDocument('movie')->getAttribute('name'));
+        $this->assertArrayNotHasKey('length', $review->getDocument('movie'));
 
         $review = $database->getDocument('review', 'review1', [
-            Query::select(['*', 'movie.name'])
+            Query::select(['*', 'movie.name']),
         ]);
 
-        $this->assertEquals('Movie 1', $review->getAttribute('movie')->getAttribute('name'));
-        $this->assertArrayNotHasKey('length', $review->getAttribute('movie'));
+        $this->assertEquals('Movie 1', $review->getDocument('movie')->getAttribute('name'));
+        $this->assertArrayNotHasKey('length', $review->getDocument('movie'));
 
         // Update root document attribute without altering relationship
         $review1 = $database->updateDocument(
@@ -205,7 +213,7 @@ public function testManyToOneOneWayRelationship(): void
         $this->assertEquals('Review 1 Updated', $review1->getAttribute('name'));
 
         // Update nested document attribute
-        $movie = $review1->getAttribute('movie');
+        $movie = $review1->getDocument('movie');
         $movie->setAttribute('name', 'Movie 1 Updated');
 
         $review1 = $database->updateDocument(
@@ -214,9 +222,9 @@ public function testManyToOneOneWayRelationship(): void
             $review1->setAttribute('movie', $movie)
         );
 
-        $this->assertEquals('Movie 1 Updated', $review1->getAttribute('movie')->getAttribute('name'));
+        $this->assertEquals('Movie 1 Updated', $review1->getDocument('movie')->getAttribute('name'));
         $review1 = $database->getDocument('review', 'review1');
-        $this->assertEquals('Movie 1 Updated', $review1->getAttribute('movie')->getAttribute('name'));
+        $this->assertEquals('Movie 1 Updated', $review1->getDocument('movie')->getAttribute('name'));
 
         // Create new document with no relationship
         $review5 = $database->createDocument('review', new Document([
@@ -245,9 +253,9 @@ public function testManyToOneOneWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Movie 5', $review5->getAttribute('movie')->getAttribute('name'));
+        $this->assertEquals('Movie 5', $review5->getDocument('movie')->getAttribute('name'));
         $review5 = $database->getDocument('review', 'review5');
-        $this->assertEquals('Movie 5', $review5->getAttribute('movie')->getAttribute('name'));
+        $this->assertEquals('Movie 5', $review5->getDocument('movie')->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -265,8 +273,8 @@ public function testManyToOneOneWayRelationship(): void
 
         // Get document with new relationship key
         $review = $database->getDocument('review', 'review1');
-        $movie = $review->getAttribute('newMovie');
-        $this->assertEquals('movie2', $movie['$id']);
+        $movie = $review->getDocument('newMovie');
+        $this->assertEquals('movie2', $movie->getId());
 
         // Reset values
         $review1 = $database->getDocument('review', 'review1');
@@ -308,7 +316,7 @@ public function testManyToOneOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'review',
             id: 'newMovie',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         // Delete child, set parent relationship to null
@@ -322,7 +330,7 @@ public function testManyToOneOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'review',
             id: 'newMovie',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete child, will delete parent
@@ -335,7 +343,6 @@ public function testManyToOneOneWayRelationship(): void
         $library = $database->getDocument('review', 'review2');
         $this->assertEquals(true, $library->isEmpty());
 
-
         // Delete relationship
         $database->deleteRelationship(
             'review',
@@ -353,60 +360,49 @@ public function testManyToOneTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('product');
-        $database->createCollection('store');
+        $database->createCollection(new Collection(id: 'product'));
+        $database->createCollection(new Collection(id: 'store'));
 
-        $database->createAttribute('store', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('store', 'opensAt', Database::VAR_STRING, 5, true);
+        $database->createAttribute('store', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('store', Attribute::string(key: 'opensAt', size: 5, required: true));
 
-        $database->createAttribute(
-            collection: 'product',
-            id: 'name',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: true
-        );
+        $database->createAttribute('product', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'product',
-            relatedCollection: 'store',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            twoWayKey: 'products'
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'product', relatedCollection: 'store', twoWay: true, twoWayKey: 'products'));
 
         // Check metadata for collection
         $collection = $database->getCollection('product');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'store') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('store', $attribute['$id']);
-                $this->assertEquals('store', $attribute['key']);
-                $this->assertEquals('store', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('products', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'store') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('store', $attribute->getId());
+                $this->assertEquals('store', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('store', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('products', $options['twoWayKey'] ?? null);
             }
         }
 
         // Check metadata for related collection
         $collection = $database->getCollection('store');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'products') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('products', $attribute['$id']);
-                $this->assertEquals('products', $attribute['key']);
-                $this->assertEquals('product', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_MANY_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('store', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'products') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('products', $attribute->getId());
+                $this->assertEquals('products', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('product', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::ManyToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('store', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -510,44 +506,44 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Get document with relationship
         $product = $database->getDocument('product', 'product1');
-        $store = $product->getAttribute('store', []);
-        $this->assertEquals('store1', $store['$id']);
+        $store = $product->getDocument('store');
+        $this->assertEquals('store1', $store->getId());
         $this->assertArrayNotHasKey('products', $store);
 
         $product = $database->getDocument('product', 'product2');
-        $store = $product->getAttribute('store', []);
-        $this->assertEquals('store2', $store['$id']);
+        $store = $product->getDocument('store');
+        $this->assertEquals('store2', $store->getId());
         $this->assertArrayNotHasKey('products', $store);
 
         $product = $database->getDocument('product', 'product3');
-        $store = $product->getAttribute('store', []);
-        $this->assertEquals('store3', $store['$id']);
+        $store = $product->getDocument('store');
+        $this->assertEquals('store3', $store->getId());
         $this->assertArrayNotHasKey('products', $store);
 
         $product = $database->getDocument('product', 'product4');
-        $store = $product->getAttribute('store', []);
-        $this->assertEquals('store4', $store['$id']);
+        $store = $product->getDocument('store');
+        $this->assertEquals('store4', $store->getId());
         $this->assertArrayNotHasKey('products', $store);
 
         // Get related document
         $store = $database->getDocument('store', 'store1');
-        $products = $store->getAttribute('products');
-        $this->assertEquals('product1', $products[0]['$id']);
+        $products = $store->getDocuments('products');
+        $this->assertEquals('product1', $products[0]->getId());
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store2');
-        $products = $store->getAttribute('products');
-        $this->assertEquals('product2', $products[0]['$id']);
+        $products = $store->getDocuments('products');
+        $this->assertEquals('product2', $products[0]->getId());
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store3');
-        $products = $store->getAttribute('products');
-        $this->assertEquals('product3', $products[0]['$id']);
+        $products = $store->getDocuments('products');
+        $this->assertEquals('product3', $products[0]->getId());
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store4');
-        $products = $store->getAttribute('products');
-        $this->assertEquals('product4', $products[0]['$id']);
+        $products = $store->getDocuments('products');
+        $this->assertEquals('product4', $products[0]->getId());
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $products = $database->find('product');
@@ -556,22 +552,22 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Select related document attributes
         $product = $database->findOne('product', [
-            Query::select(['*', 'store.name'])
+            Query::select(['*', 'store.name']),
         ]);
 
         if ($product->isEmpty()) {
             throw new Exception('Product not found');
         }
 
-        $this->assertEquals('Store 1', $product->getAttribute('store')->getAttribute('name'));
-        $this->assertArrayNotHasKey('opensAt', $product->getAttribute('store'));
+        $this->assertEquals('Store 1', $product->getDocument('store')->getAttribute('name'));
+        $this->assertArrayNotHasKey('opensAt', $product->getDocument('store'));
 
         $product = $database->getDocument('product', 'product1', [
-            Query::select(['*', 'store.name'])
+            Query::select(['*', 'store.name']),
         ]);
 
-        $this->assertEquals('Store 1', $product->getAttribute('store')->getAttribute('name'));
-        $this->assertArrayNotHasKey('opensAt', $product->getAttribute('store'));
+        $this->assertEquals('Store 1', $product->getDocument('store')->getAttribute('name'));
+        $this->assertArrayNotHasKey('opensAt', $product->getDocument('store'));
 
         // Update root document attribute without altering relationship
         $product1 = $database->updateDocument(
@@ -597,7 +593,7 @@ public function testManyToOneTwoWayRelationship(): void
         $this->assertEquals('Store 1 Updated', $store1->getAttribute('name'));
 
         // Update nested document attribute
-        $store = $product1->getAttribute('store');
+        $store = $product1->getDocument('store');
         $store->setAttribute('name', 'Store 1 Updated');
 
         $product1 = $database->updateDocument(
@@ -606,12 +602,12 @@ public function testManyToOneTwoWayRelationship(): void
             $product1->setAttribute('store', $store)
         );
 
-        $this->assertEquals('Store 1 Updated', $product1->getAttribute('store')->getAttribute('name'));
+        $this->assertEquals('Store 1 Updated', $product1->getDocument('store')->getAttribute('name'));
         $product1 = $database->getDocument('product', 'product1');
-        $this->assertEquals('Store 1 Updated', $product1->getAttribute('store')->getAttribute('name'));
+        $this->assertEquals('Store 1 Updated', $product1->getDocument('store')->getAttribute('name'));
 
         // Update inverse nested document attribute
-        $product = $store1->getAttribute('products')[0];
+        $product = $store1->getDocuments('products')[0];
         $product->setAttribute('name', 'Product 1 Updated');
 
         $store1 = $database->updateDocument(
@@ -620,9 +616,9 @@ public function testManyToOneTwoWayRelationship(): void
             $store1->setAttribute('products', [$product])
         );
 
-        $this->assertEquals('Product 1 Updated', $store1->getAttribute('products')[0]->getAttribute('name'));
+        $this->assertEquals('Product 1 Updated', $store1->getDocuments('products')[0]->getAttribute('name'));
         $store1 = $database->getDocument('store', 'store1');
-        $this->assertEquals('Product 1 Updated', $store1->getAttribute('products')[0]->getAttribute('name'));
+        $this->assertEquals('Product 1 Updated', $store1->getDocuments('products')[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $product5 = $database->createDocument('product', new Document([
@@ -651,9 +647,9 @@ public function testManyToOneTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Store 5', $product5->getAttribute('store')->getAttribute('name'));
+        $this->assertEquals('Store 5', $product5->getDocument('store')->getAttribute('name'));
         $product5 = $database->getDocument('product', 'product5');
-        $this->assertEquals('Store 5', $product5->getAttribute('store')->getAttribute('name'));
+        $this->assertEquals('Store 5', $product5->getDocument('store')->getAttribute('name'));
 
         // Create new child document with no relationship
         $store6 = $database->createDocument('store', new Document([
@@ -682,9 +678,9 @@ public function testManyToOneTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Product 6', $store6->getAttribute('products')[0]->getAttribute('name'));
+        $this->assertEquals('Product 6', $store6->getDocuments('products')[0]->getAttribute('name'));
         $store6 = $database->getDocument('store', 'store6');
-        $this->assertEquals('Product 6', $store6->getAttribute('products')[0]->getAttribute('name'));
+        $this->assertEquals('Product 6', $store6->getDocuments('products')[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -721,13 +717,13 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Get document with new relationship key
         $store = $database->getDocument('store', 'store2');
-        $products = $store->getAttribute('newProducts');
-        $this->assertEquals('product1', $products[0]['$id']);
+        $products = $store->getDocuments('newProducts');
+        $this->assertEquals('product1', $products[0]->getId());
 
         // Get inverse document with new relationship key
         $product = $database->getDocument('product', 'product1');
-        $store = $product->getAttribute('newStore');
-        $this->assertEquals('store2', $store['$id']);
+        $store = $product->getDocument('newStore');
+        $this->assertEquals('store2', $store->getId());
 
         // Reset relationships
         $store1 = $database->getDocument('store', 'store1');
@@ -772,7 +768,7 @@ public function testManyToOneTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'product',
             id: 'newStore',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         // Delete child, set parent relationship to null
@@ -786,7 +782,7 @@ public function testManyToOneTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'product',
             id: 'newStore',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete child, will delete parent
@@ -821,34 +817,28 @@ public function testNestedManyToOne_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('towns');
-        $database->createCollection('homelands');
-        $database->createCollection('capitals');
+        $database->createCollection(new Collection(id: 'towns'));
+        $database->createCollection(new Collection(id: 'homelands'));
+        $database->createCollection(new Collection(id: 'capitals'));
 
-        $database->createAttribute('towns', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('homelands', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('capitals', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('towns', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('homelands', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('capitals', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'towns',
-            relatedCollection: 'homelands',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'homeland'
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(collection: 'towns', relatedCollection: 'homelands', twoWay: true, key: 'homeland'));
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'homelands',
             relatedCollection: 'capitals',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'capital',
+            key: 'capital',
             twoWayKey: 'homeland'
-        );
+        ));
 
         $database->createDocument('towns', new Document([
             '$id' => 'town1',
@@ -873,10 +863,12 @@ public function testNestedManyToOne_OneToOneRelationship(): void
         ]));
 
         $town1 = $database->getDocument('towns', 'town1');
-        $this->assertEquals('homeland1', $town1['homeland']['$id']);
-        $this->assertArrayNotHasKey('towns', $town1['homeland']);
-        $this->assertEquals('capital1', $town1['homeland']['capital']['$id']);
-        $this->assertArrayNotHasKey('homeland', $town1['homeland']['capital']);
+        $homeland = $town1->getDocument('homeland');
+        $this->assertEquals('homeland1', $homeland->getId());
+        $this->assertArrayNotHasKey('towns', $homeland);
+        $capital = $homeland->getDocument('capital');
+        $this->assertEquals('capital1', $capital->getId());
+        $this->assertArrayNotHasKey('homeland', $capital);
 
         $database->createDocument('capitals', new Document([
             '$id' => 'capital2',
@@ -910,11 +902,13 @@ public function testNestedManyToOne_OneToOneRelationship(): void
         ]));
 
         $capital2 = $database->getDocument('capitals', 'capital2');
-        $this->assertEquals('homeland2', $capital2['homeland']['$id']);
-        $this->assertArrayNotHasKey('capital', $capital2['homeland']);
-        $this->assertEquals(2, \count($capital2['homeland']['towns']));
-        $this->assertEquals('town2', $capital2['homeland']['towns'][0]['$id']);
-        $this->assertEquals('town3', $capital2['homeland']['towns'][1]['$id']);
+        $homeland = $capital2->getDocument('homeland');
+        $this->assertEquals('homeland2', $homeland->getId());
+        $this->assertArrayNotHasKey('capital', $homeland);
+        $towns = $homeland->getDocuments('towns');
+        $this->assertCount(2, $towns);
+        $this->assertEquals('town2', $towns[0]->getId());
+        $this->assertEquals('town3', $towns[1]->getId());
     }
 
     public function testNestedManyToOne_OneToManyRelationship(): void
@@ -922,34 +916,28 @@ public function testNestedManyToOne_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('players');
-        $database->createCollection('teams');
-        $database->createCollection('supporters');
+        $database->createCollection(new Collection(id: 'players'));
+        $database->createCollection(new Collection(id: 'teams'));
+        $database->createCollection(new Collection(id: 'supporters'));
 
-        $database->createAttribute('players', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('teams', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('supporters', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('players', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('teams', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('supporters', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'players',
-            relatedCollection: 'teams',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'team'
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(collection: 'players', relatedCollection: 'teams', twoWay: true, key: 'team'));
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'teams',
             relatedCollection: 'supporters',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'supporters',
+            key: 'supporters',
             twoWayKey: 'team'
-        );
+        ));
 
         $database->createDocument('players', new Document([
             '$id' => 'player1',
@@ -983,11 +971,13 @@ public function testNestedManyToOne_OneToManyRelationship(): void
         ]));
 
         $player1 = $database->getDocument('players', 'player1');
-        $this->assertEquals('team1', $player1['team']['$id']);
-        $this->assertArrayNotHasKey('players', $player1['team']);
-        $this->assertEquals(2, \count($player1['team']['supporters']));
-        $this->assertEquals('supporter1', $player1['team']['supporters'][0]['$id']);
-        $this->assertEquals('supporter2', $player1['team']['supporters'][1]['$id']);
+        $team = $player1->getDocument('team');
+        $this->assertEquals('team1', $team->getId());
+        $this->assertArrayNotHasKey('players', $team);
+        $supporters = $team->getDocuments('supporters');
+        $this->assertCount(2, $supporters);
+        $this->assertEquals('supporter1', $supporters[0]->getId());
+        $this->assertEquals('supporter2', $supporters[1]->getId());
 
         $database->createDocument('supporters', new Document([
             '$id' => 'supporter3',
@@ -1021,11 +1011,13 @@ public function testNestedManyToOne_OneToManyRelationship(): void
         ]));
 
         $supporter3 = $database->getDocument('supporters', 'supporter3');
-        $this->assertEquals('team2', $supporter3['team']['$id']);
-        $this->assertArrayNotHasKey('supporters', $supporter3['team']);
-        $this->assertEquals(2, \count($supporter3['team']['players']));
-        $this->assertEquals('player2', $supporter3['team']['players'][0]['$id']);
-        $this->assertEquals('player3', $supporter3['team']['players'][1]['$id']);
+        $team = $supporter3->getDocument('team');
+        $this->assertEquals('team2', $team->getId());
+        $this->assertArrayNotHasKey('supporters', $team);
+        $players = $team->getDocuments('players');
+        $this->assertCount(2, $players);
+        $this->assertEquals('player2', $players[0]->getId());
+        $this->assertEquals('player3', $players[1]->getId());
     }
 
     public function testNestedManyToOne_ManyToOne(): void
@@ -1033,33 +1025,22 @@ public function testNestedManyToOne_ManyToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('cows');
-        $database->createCollection('farms');
-        $database->createCollection('farmer');
+        $database->createCollection(new Collection(id: 'cows'));
+        $database->createCollection(new Collection(id: 'farms'));
+        $database->createCollection(new Collection(id: 'farmer'));
 
-        $database->createAttribute('cows', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('farms', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('farmer', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('cows', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('farms', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('farmer', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'cows',
-            relatedCollection: 'farms',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'farm'
-        );
-        $database->createRelationship(
-            collection: 'farms',
-            relatedCollection: 'farmer',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'farmer'
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'cows', relatedCollection: 'farms', twoWay: true, key: 'farm'));
+        $database->createRelationship(Relationship::manyToOne(collection: 'farms', relatedCollection: 'farmer', twoWay: true, key: 'farmer'));
 
         $database->createDocument('cows', new Document([
             '$id' => 'cow1',
@@ -1084,10 +1065,12 @@ public function testNestedManyToOne_ManyToOne(): void
         ]));
 
         $cow1 = $database->getDocument('cows', 'cow1');
-        $this->assertEquals('farm1', $cow1['farm']['$id']);
-        $this->assertArrayNotHasKey('cows', $cow1['farm']);
-        $this->assertEquals('farmer1', $cow1['farm']['farmer']['$id']);
-        $this->assertArrayNotHasKey('farms', $cow1['farm']['farmer']);
+        $farm = $cow1->getDocument('farm');
+        $this->assertEquals('farm1', $farm->getId());
+        $this->assertArrayNotHasKey('cows', $farm);
+        $farmer = $farm->getDocument('farmer');
+        $this->assertEquals('farmer1', $farmer->getId());
+        $this->assertArrayNotHasKey('farms', $farmer);
 
         $database->createDocument('farmer', new Document([
             '$id' => 'farmer2',
@@ -1123,11 +1106,13 @@ public function testNestedManyToOne_ManyToOne(): void
         ]));
 
         $farmer2 = $database->getDocument('farmer', 'farmer2');
-        $this->assertEquals('farm2', $farmer2['farms'][0]['$id']);
-        $this->assertArrayNotHasKey('farmer', $farmer2['farms'][0]);
-        $this->assertEquals(2, \count($farmer2['farms'][0]['cows']));
-        $this->assertEquals('cow2', $farmer2['farms'][0]['cows'][0]['$id']);
-        $this->assertEquals('cow3', $farmer2['farms'][0]['cows'][1]['$id']);
+        $farms = $farmer2->getDocuments('farms');
+        $this->assertEquals('farm2', $farms[0]->getId());
+        $this->assertArrayNotHasKey('farmer', $farms[0]);
+        $cows = $farms[0]->getDocuments('cows');
+        $this->assertCount(2, $cows);
+        $this->assertEquals('cow2', $cows[0]->getId());
+        $this->assertEquals('cow3', $cows[1]->getId());
     }
 
     public function testNestedManyToOne_ManyToManyRelationship(): void
@@ -1135,32 +1120,22 @@ public function testNestedManyToOne_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('books');
-        $database->createCollection('entrants');
-        $database->createCollection('rooms');
+        $database->createCollection(new Collection(id: 'books'));
+        $database->createCollection(new Collection(id: 'entrants'));
+        $database->createCollection(new Collection(id: 'rooms'));
 
-        $database->createAttribute('books', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('entrants', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('rooms', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('books', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('entrants', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('rooms', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'books',
-            relatedCollection: 'entrants',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'entrant'
-        );
-        $database->createRelationship(
-            collection: 'entrants',
-            relatedCollection: 'rooms',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: 'books', relatedCollection: 'entrants', twoWay: true, key: 'entrant'));
+        $database->createRelationship(Relationship::manyToMany(collection: 'entrants', relatedCollection: 'rooms', twoWay: true));
 
         $database->createDocument('books', new Document([
             '$id' => 'book1',
@@ -1194,11 +1169,13 @@ public function testNestedManyToOne_ManyToManyRelationship(): void
         ]));
 
         $book1 = $database->getDocument('books', 'book1');
-        $this->assertEquals('entrant1', $book1['entrant']['$id']);
-        $this->assertArrayNotHasKey('books', $book1['entrant']);
-        $this->assertEquals(2, \count($book1['entrant']['rooms']));
-        $this->assertEquals('class1', $book1['entrant']['rooms'][0]['$id']);
-        $this->assertEquals('class2', $book1['entrant']['rooms'][1]['$id']);
+        $entrant = $book1->getDocument('entrant');
+        $this->assertEquals('entrant1', $entrant->getId());
+        $this->assertArrayNotHasKey('books', $entrant);
+        $rooms = $entrant->getDocuments('rooms');
+        $this->assertCount(2, $rooms);
+        $this->assertEquals('class1', $rooms[0]->getId());
+        $this->assertEquals('class2', $rooms[1]->getId());
     }
 
     public function testExceedMaxDepthManyToOneParent(): void
@@ -1206,8 +1183,9 @@ public function testExceedMaxDepthManyToOneParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1216,29 +1194,14 @@ public function testExceedMaxDepthManyToOneParent(): void
         $level3Collection = 'level3ManyToOneParent';
         $level4Collection = 'level4ManyToOneParent';
 
-        $database->createCollection($level1Collection);
-        $database->createCollection($level2Collection);
-        $database->createCollection($level3Collection);
-        $database->createCollection($level4Collection);
+        $database->createCollection(new Collection(id: $level1Collection));
+        $database->createCollection(new Collection(id: $level2Collection));
+        $database->createCollection(new Collection(id: $level3Collection));
+        $database->createCollection(new Collection(id: $level4Collection));
 
-        $database->createRelationship(
-            collection: $level1Collection,
-            relatedCollection: $level2Collection,
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level2Collection,
-            relatedCollection: $level3Collection,
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level3Collection,
-            relatedCollection: $level4Collection,
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $level1Collection, relatedCollection: $level2Collection, twoWay: true));
+        $database->createRelationship(Relationship::manyToOne(collection: $level2Collection, relatedCollection: $level3Collection, twoWay: true));
+        $database->createRelationship(Relationship::manyToOne(collection: $level3Collection, relatedCollection: $level4Collection, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1257,31 +1220,31 @@ public function testExceedMaxDepthManyToOneParent(): void
             ],
         ]));
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level1->getDocument($level2Collection)->getId());
+        $this->assertArrayHasKey($level3Collection, $level1->getDocument($level2Collection));
+        $this->assertEquals('level3', $level1->getDocument($level2Collection)->getDocument($level3Collection)->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level1->getDocument($level2Collection)->getDocument($level3Collection));
 
         // Confirm the 4th level document does not exist
         $level3 = $database->getDocument($level3Collection, 'level3');
-        $this->assertNull($level3[$level4Collection]);
+        $this->assertNull($level3->getAttribute($level4Collection));
 
         // Create level 4 document
         $level3->setAttribute($level4Collection, new Document([
             '$id' => 'level4',
         ]));
         $level3 = $database->updateDocument($level3Collection, $level3->getId(), $level3);
-        $this->assertEquals('level4', $level3[$level4Collection]->getId());
+        $this->assertEquals('level4', $level3->getDocument($level4Collection)->getId());
         $level3 = $database->getDocument($level3Collection, 'level3');
-        $this->assertEquals('level4', $level3[$level4Collection]->getId());
+        $this->assertEquals('level4', $level3->getDocument($level4Collection)->getId());
 
         // Exceed fetch depth
         $level1 = $database->getDocument($level1Collection, 'level1');
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level1->getDocument($level2Collection)->getId());
+        $this->assertArrayHasKey($level3Collection, $level1->getDocument($level2Collection));
+        $this->assertEquals('level3', $level1->getDocument($level2Collection)->getDocument($level3Collection)->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level1->getDocument($level2Collection)->getDocument($level3Collection));
     }
 
     public function testManyToOneRelationshipKeyWithSymbols(): void
@@ -1289,109 +1252,81 @@ public function testManyToOneRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('$symbols_coll.ection5');
-        $database->createCollection('$symbols_coll.ection6');
+        $database->createCollection(new Collection(id: '$symbols_coll.ection5'));
+        $database->createCollection(new Collection(id: '$symbols_coll.ection6'));
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection5',
-            relatedCollection: '$symbols_coll.ection6',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: '$symbols_coll.ection5', relatedCollection: '$symbols_coll.ection6', twoWay: true));
 
         $doc1 = $database->createDocument('$symbols_coll.ection6', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
         $doc2 = $database->createDocument('$symbols_coll.ection5', new Document([
             '$id' => ID::unique(),
-            '$symbols_coll.ection6' => $doc1->getId(),
+            'symbols_collection6' => $doc1->getId(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
 
         $doc1 = $database->getDocument('$symbols_coll.ection6', $doc1->getId());
         $doc2 = $database->getDocument('$symbols_coll.ection5', $doc2->getId());
 
-        $this->assertEquals($doc2->getId(), $doc1->getAttribute('$symbols_coll.ection5')[0]->getId());
-        $this->assertEquals($doc1->getId(), $doc2->getAttribute('$symbols_coll.ection6')->getId());
+        $this->assertEquals($doc2->getId(), $doc1->getDocuments('symbols_collection5')[0]->getId());
+        $this->assertEquals($doc1->getId(), $doc2->getDocument('symbols_collection6')->getId());
     }
 
-
     public function testRecreateManyToOneOneWayRelationshipFromParent(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $result = $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToOneOneWayRelationshipFromChild(): void
@@ -1399,65 +1334,42 @@ public function testRecreateManyToOneOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $result = $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToOneTwoWayRelationshipFromParent(): void
@@ -1465,134 +1377,85 @@ public function testRecreateManyToOneTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
+
     public function testRecreateManyToOneTwoWayRelationshipFromChild(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::manyToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsManyToOneRelationship(): void
@@ -1600,25 +1463,21 @@ public function testDeleteBulkDocumentsManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->createCollection('bulk_delete_person_m2o');
-        $this->getDatabase()->createCollection('bulk_delete_library_m2o');
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_person_m2o'));
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_library_m2o'));
 
-        $this->getDatabase()->createAttribute('bulk_delete_person_m2o', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', 'area', Database::VAR_STRING, 255, true);
+        $this->getDatabase()->createAttribute('bulk_delete_person_m2o', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', Attribute::string(key: 'area', required: true));
 
         // Many-to-One Relationship
-        $this->getDatabase()->createRelationship(
-            collection: 'bulk_delete_person_m2o',
-            relatedCollection: 'bulk_delete_library_m2o',
-            type: Database::RELATION_MANY_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $this->getDatabase()->createRelationship(Relationship::manyToOne(collection: 'bulk_delete_person_m2o', relatedCollection: 'bulk_delete_library_m2o'));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_m2o', new Document([
             '$id' => 'person1',
@@ -1650,12 +1509,12 @@ public function testDeleteBulkDocumentsManyToOneRelationship(): void
             'name' => 'Person 2',
             'bulk_delete_library_m2o' => [
                 '$id' => 'library1',
-            ]
+            ],
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_m2o', 'person1');
-        $library = $person1->getAttribute('bulk_delete_library_m2o');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('bulk_delete_library_m2o');
+        $this->assertEquals('library1', $library->getId());
 
         // Delete library
         try {
@@ -1678,34 +1537,32 @@ public function testDeleteBulkDocumentsManyToOneRelationship(): void
         $this->getDatabase()->deleteDocuments('bulk_delete_person_m2o');
         $this->assertCount(0, $this->getDatabase()->find('bulk_delete_person_m2o'));
     }
+
     public function testUpdateParentAndChild_ManyToOne(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
         if (
-            !$database->getAdapter()->getSupportForRelationships() ||
-            !$database->getAdapter()->getSupportForBatchOperations()
+            ! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_combined_m2o';
         $childCollection = 'child_combined_m2o';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
 
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'parentNumber', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::integer(key: 'parentNumber'));
 
-        $database->createRelationship(
-            collection: $childCollection,
-            relatedCollection: $parentCollection,
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $childCollection, relatedCollection: $parentCollection));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1765,25 +1622,21 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToOn
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_relationship_error_many_to_one';
         $childCollection = 'child_relationship_error_many_to_one';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: $childCollection,
-            relatedCollection: $parentCollection,
-            type: Database::RELATION_MANY_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createRelationship(Relationship::manyToOne(collection: $childCollection, relatedCollection: $parentCollection));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1803,7 +1656,7 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToOn
                 Permission::delete(Role::any()),
             ],
             'name' => 'Child 1',
-            $parentCollection => 'parent1'
+            $parentCollection => 'parent1',
         ]));
 
         try {
@@ -1825,26 +1678,26 @@ public function testPartialUpdateManyToOneParentSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('companies');
-        $database->createCollection('employees');
+        $database->createCollection(new Collection(id: 'companies'));
+        $database->createCollection(new Collection(id: 'employees'));
 
-        $database->createAttribute('companies', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('employees', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('employees', 'salary', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute('companies', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('employees', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('employees', Attribute::integer(key: 'salary'));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'employees',
             relatedCollection: 'companies',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'company',
+            key: 'company',
             twoWayKey: 'employees'
-        );
+        ));
 
         // Create company
         $database->createDocument('companies', new Document([
@@ -1879,7 +1732,7 @@ public function testPartialUpdateManyToOneParentSide(): void
         $emp = $database->getDocument('employees', 'emp1');
         $this->assertEquals('Alice', $emp->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals(120000, $emp->getAttribute('salary'), 'Salary should be updated');
-        $this->assertEquals('company1', $emp->getAttribute('company')->getId(), 'Company relationship should be preserved');
+        $this->assertEquals('company1', $emp->getDocument('company')->getId(), 'Company relationship should be preserved');
 
         // Partial update - change only company relationship
         $database->updateDocument('employees', 'emp1', new Document([
@@ -1892,7 +1745,7 @@ public function testPartialUpdateManyToOneParentSide(): void
         $emp = $database->getDocument('employees', 'emp1');
         $this->assertEquals('Alice', $emp->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals(120000, $emp->getAttribute('salary'), 'Salary should be preserved');
-        $this->assertEquals('company2', $emp->getAttribute('company')->getId(), 'Company should be updated');
+        $this->assertEquals('company2', $emp->getDocument('company')->getId(), 'Company should be updated');
 
         $database->deleteCollection('companies');
         $database->deleteCollection('employees');
@@ -1903,26 +1756,26 @@ public function testPartialUpdateManyToOneChildSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('departments');
-        $database->createCollection('staff');
+        $database->createCollection(new Collection(id: 'departments'));
+        $database->createCollection(new Collection(id: 'staff'));
 
-        $database->createAttribute('departments', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('departments', 'budget', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute('staff', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('departments', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('departments', Attribute::integer(key: 'budget'));
+        $database->createAttribute('staff', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'staff',
             relatedCollection: 'departments',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'department',
+            key: 'department',
             twoWayKey: 'staff'
-        );
+        ));
 
         // Create department with staff
         $database->createDocument('departments', new Document([
@@ -1947,7 +1800,7 @@ public function testPartialUpdateManyToOneChildSide(): void
         $dept = $database->getDocument('departments', 'dept1');
         $this->assertEquals('Engineering', $dept->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals(1200000, $dept->getAttribute('budget'), 'Budget should be updated');
-        $this->assertCount(2, $dept->getAttribute('staff'), 'Staff should be preserved');
+        $this->assertCount(2, $dept->getDocuments('staff'), 'Staff should be preserved');
 
         $database->deleteCollection('departments');
         $database->deleteCollection('staff');
diff --git a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
index 7923191cd5..0947548b3f 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
@@ -3,6 +3,10 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +15,10 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait OneToManyTests
 {
@@ -19,38 +27,33 @@ public function testOneToManyOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('artist');
-        $database->createCollection('album');
+        $database->createCollection(new Collection(id: 'artist'));
+        $database->createCollection(new Collection(id: 'album'));
 
-        $database->createAttribute('artist', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('album', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('album', 'price', Database::VAR_FLOAT, 0, true);
+        $database->createAttribute('artist', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('album', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('album', Attribute::double(key: 'price', required: true));
 
-        $database->createRelationship(
-            collection: 'artist',
-            relatedCollection: 'album',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'albums'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'artist', relatedCollection: 'album', key: 'albums'));
 
         // Check metadata for collection
         $collection = $database->getCollection('artist');
-        $attributes = $collection->getAttribute('attributes', []);
-
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'albums') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('albums', $attribute['$id']);
-                $this->assertEquals('albums', $attribute['key']);
-                $this->assertEquals('album', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(false, $attribute['options']['twoWay']);
-                $this->assertEquals('artist', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'albums') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('albums', $attribute->getId());
+                $this->assertEquals('albums', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('album', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(false, $options['twoWay'] ?? null);
+                $this->assertEquals('artist', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -68,7 +71,7 @@ public function testOneToManyOneWayRelationship(): void
                     '$id' => 'album1',
                     '$permissions' => [
                         Permission::read(Role::any()),
-                        Permission::update(Role::any())
+                        Permission::update(Role::any()),
                     ],
                     'name' => 'Album 1',
                     'price' => 9.99,
@@ -81,7 +84,7 @@ public function testOneToManyOneWayRelationship(): void
 
         $artist1Document = $database->getDocument('artist', 'artist1');
         // Assert document does not contain non existing relation document.
-        $this->assertEquals(1, \count($artist1Document->getAttribute('albums')));
+        $this->assertEquals(1, \count($artist1Document->getDocuments('albums')));
 
         // Create document with relationship with related ID
         $database->createDocument('album', new Document([
@@ -112,27 +115,27 @@ public function testOneToManyOneWayRelationship(): void
                     ],
                     'name' => 'Album 3',
                     'price' => 33.33,
-                ]
-            ]
+                ],
+            ],
         ]));
 
         $documents = $database->find('artist', [
             Query::select(['name']),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertArrayNotHasKey('albums', $documents[0]);
 
         // Get document with relationship
         $artist = $database->getDocument('artist', 'artist1');
-        $albums = $artist->getAttribute('albums', []);
-        $this->assertEquals('album1', $albums[0]['$id']);
+        $albums = $artist->getDocuments('albums');
+        $this->assertEquals('album1', $albums[0]->getId());
         $this->assertArrayNotHasKey('artist', $albums[0]);
 
         $artist = $database->getDocument('artist', 'artist2');
-        $albums = $artist->getAttribute('albums', []);
-        $this->assertEquals('album2', $albums[0]['$id']);
+        $albums = $artist->getDocuments('albums');
+        $this->assertEquals('album2', $albums[0]->getId());
         $this->assertArrayNotHasKey('artist', $albums[0]);
-        $this->assertEquals('album33', $albums[1]['$id']);
+        $this->assertEquals('album33', $albums[1]->getId());
         $this->assertCount(2, $albums);
 
         // Get related document
@@ -148,22 +151,22 @@ public function testOneToManyOneWayRelationship(): void
 
         // Select related document attributes
         $artist = $database->findOne('artist', [
-            Query::select(['*', 'albums.name'])
+            Query::select(['*', 'albums.name']),
         ]);
 
         if ($artist->isEmpty()) {
             $this->fail('Artist not found');
         }
 
-        $this->assertEquals('Album 1', $artist->getAttribute('albums')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('price', $artist->getAttribute('albums')[0]);
+        $this->assertEquals('Album 1', $artist->getDocuments('albums')[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('price', $artist->getDocuments('albums')[0]);
 
         $artist = $database->getDocument('artist', 'artist1', [
-            Query::select(['*', 'albums.name'])
+            Query::select(['*', 'albums.name']),
         ]);
 
-        $this->assertEquals('Album 1', $artist->getAttribute('albums')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('price', $artist->getAttribute('albums')[0]);
+        $this->assertEquals('Album 1', $artist->getDocuments('albums')[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('price', $artist->getDocuments('albums')[0]);
 
         // Update root document attribute without altering relationship
         $artist1 = $database->updateDocument(
@@ -177,7 +180,7 @@ public function testOneToManyOneWayRelationship(): void
         $this->assertEquals('Artist 1 Updated', $artist1->getAttribute('name'));
 
         // Update nested document attribute
-        $albums = $artist1->getAttribute('albums', []);
+        $albums = $artist1->getDocuments('albums');
         $albums[0]->setAttribute('name', 'Album 1 Updated');
 
         $artist1 = $database->updateDocument(
@@ -186,20 +189,20 @@ public function testOneToManyOneWayRelationship(): void
             $artist1->setAttribute('albums', $albums)
         );
 
-        $this->assertEquals('Album 1 Updated', $artist1->getAttribute('albums')[0]->getAttribute('name'));
+        $this->assertEquals('Album 1 Updated', $artist1->getDocuments('albums')[0]->getAttribute('name'));
         $artist1 = $database->getDocument('artist', 'artist1');
-        $this->assertEquals('Album 1 Updated', $artist1->getAttribute('albums')[0]->getAttribute('name'));
+        $this->assertEquals('Album 1 Updated', $artist1->getDocuments('albums')[0]->getAttribute('name'));
 
-        $albumId = $artist1->getAttribute('albums')[0]->getAttribute('$id');
+        $albumId = $artist1->getDocuments('albums')[0]->getId();
         $albumDocument = $database->getDocument('album', $albumId);
         $albumDocument->setAttribute('name', 'Album 1 Updated!!!');
         $database->updateDocument('album', $albumDocument->getId(), $albumDocument);
         $albumDocument = $database->getDocument('album', $albumDocument->getId());
         $artist1 = $database->getDocument('artist', $artist1->getId());
 
-        $this->assertEquals('Album 1 Updated!!!', $albumDocument['name']);
-        $this->assertEquals($albumDocument->getId(), $artist1->getAttribute('albums')[0]->getId());
-        $this->assertEquals($albumDocument->getAttribute('name'), $artist1->getAttribute('albums')[0]->getAttribute('name'));
+        $this->assertEquals('Album 1 Updated!!!', $albumDocument->getAttribute('name'));
+        $this->assertEquals($albumDocument->getId(), $artist1->getDocuments('albums')[0]->getId());
+        $this->assertEquals($albumDocument->getAttribute('name'), $artist1->getDocuments('albums')[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $artist3 = $database->createDocument('artist', new Document([
@@ -228,9 +231,9 @@ public function testOneToManyOneWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Album 3', $artist3->getAttribute('albums')[0]->getAttribute('name'));
+        $this->assertEquals('Album 3', $artist3->getDocuments('albums')[0]->getAttribute('name'));
         $artist3 = $database->getDocument('artist', 'artist3');
-        $this->assertEquals('Album 3', $artist3->getAttribute('albums')[0]->getAttribute('name'));
+        $this->assertEquals('Album 3', $artist3->getDocuments('albums')[0]->getAttribute('name'));
 
         // Update document with new related documents, will remove existing relations
         $database->updateDocument(
@@ -255,8 +258,8 @@ public function testOneToManyOneWayRelationship(): void
 
         // Get document with new relationship key
         $artist = $database->getDocument('artist', 'artist1');
-        $albums = $artist->getAttribute('newAlbums');
-        $this->assertEquals('album1', $albums[0]['$id']);
+        $albums = $artist->getDocuments('newAlbums');
+        $this->assertEquals('album1', $albums[0]->getId());
 
         // Create new document with no relationship
         $database->createDocument('artist', new Document([
@@ -288,7 +291,7 @@ public function testOneToManyOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'artist',
             id: 'newAlbums',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         // Delete parent, set child relationship to null
@@ -309,7 +312,7 @@ public function testOneToManyOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'artist',
             id: 'newAlbums',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -323,15 +326,15 @@ public function testOneToManyOneWayRelationship(): void
         $this->assertEquals(true, $library->isEmpty());
 
         $albums = [];
-        for ($i = 1 ; $i <= 50 ; $i++) {
+        for ($i = 1; $i <= 50; $i++) {
             $albums[] = [
-                '$id' => 'album_' . $i,
+                '$id' => 'album_'.$i,
                 '$permissions' => [
                     Permission::read(Role::any()),
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-                'name' => 'album ' . $i . ' ' . 'Artist 100',
+                'name' => 'album '.$i.' '.'Artist 100',
                 'price' => 100,
             ];
         }
@@ -342,15 +345,15 @@ public function testOneToManyOneWayRelationship(): void
                 Permission::delete(Role::any()),
             ],
             'name' => 'Artist 100',
-            'newAlbums' => $albums
+            'newAlbums' => $albums,
         ]));
 
         $artist = $database->getDocument('artist', $artist->getId());
-        $this->assertCount(50, $artist->getAttribute('newAlbums'));
+        $this->assertCount(50, $artist->getDocuments('newAlbums'));
 
         $albums = $database->find('album', [
             Query::equal('artist', [$artist->getId()]),
-            Query::limit(999)
+            Query::limit(999),
         ]);
 
         $this->assertCount(50, $albums);
@@ -363,13 +366,13 @@ public function testOneToManyOneWayRelationship(): void
 
         $database->deleteDocument('album', 'album_1');
         $artist = $database->getDocument('artist', $artist->getId());
-        $this->assertCount(49, $artist->getAttribute('newAlbums'));
+        $this->assertCount(49, $artist->getDocuments('newAlbums'));
 
         $database->deleteDocument('artist', $artist->getId());
 
         $albums = $database->find('album', [
             Query::equal('artist', [$artist->getId()]),
-            Query::limit(999)
+            Query::limit(999),
         ]);
 
         $this->assertCount(0, $albums);
@@ -391,53 +394,48 @@ public function testOneToManyTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('customer');
-        $database->createCollection('account');
+        $database->createCollection(new Collection(id: 'customer'));
+        $database->createCollection(new Collection(id: 'account'));
 
-        $database->createAttribute('customer', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('account', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('account', 'number', Database::VAR_STRING, 255, true);
+        $database->createAttribute('customer', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('account', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('account', Attribute::string(key: 'number', required: true));
 
-        $database->createRelationship(
-            collection: 'customer',
-            relatedCollection: 'account',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'accounts'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'customer', relatedCollection: 'account', twoWay: true, key: 'accounts'));
 
         // Check metadata for collection
         $collection = $database->getCollection('customer');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'accounts') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('accounts', $attribute['$id']);
-                $this->assertEquals('accounts', $attribute['key']);
-                $this->assertEquals('account', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('customer', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'accounts') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('accounts', $attribute->getId());
+                $this->assertEquals('accounts', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('account', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('customer', $options['twoWayKey'] ?? null);
             }
         }
 
         // Check metadata for related collection
         $collection = $database->getCollection('account');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'customer') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('customer', $attribute['$id']);
-                $this->assertEquals('customer', $attribute['key']);
-                $this->assertEquals('customer', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_MANY, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('accounts', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'customer') {
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('customer', $attribute->getId());
+                $this->assertEquals('customer', $attribute->key);
+                $options = $attribute->options ?? [];
+                $this->assertEquals('customer', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToMany->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('accounts', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -465,11 +463,11 @@ public function testOneToManyTwoWayRelationship(): void
         ]));
 
         // Update a document with non existing related document. It should not get added to the list.
-        $database->updateDocument('customer', 'customer1', $customer1->setAttribute('accounts', ['account1','no-account']));
+        $database->updateDocument('customer', 'customer1', $customer1->setAttribute('accounts', ['account1', 'no-account']));
 
         $customer1Document = $database->getDocument('customer', 'customer1');
         // Assert document does not contain non existing relation document.
-        $this->assertEquals(1, \count($customer1Document->getAttribute('accounts')));
+        $this->assertEquals(1, \count($customer1Document->getDocuments('accounts')));
 
         // Create document with relationship with related ID
         $account2 = $database->createDocument('account', new Document([
@@ -491,8 +489,8 @@ public function testOneToManyTwoWayRelationship(): void
             ],
             'name' => 'Customer 2',
             'accounts' => [
-                'account2'
-            ]
+                'account2',
+            ],
         ]));
 
         // Create from child side
@@ -512,8 +510,8 @@ public function testOneToManyTwoWayRelationship(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-                'name' => 'Customer 3'
-            ]
+                'name' => 'Customer 3',
+            ],
         ]));
         $database->createDocument('customer', new Document([
             '$id' => 'customer4',
@@ -533,49 +531,49 @@ public function testOneToManyTwoWayRelationship(): void
             ],
             'name' => 'Account 4',
             'number' => '123456789',
-            'customer' => 'customer4'
+            'customer' => 'customer4',
         ]));
 
         // Get documents with relationship
         $customer = $database->getDocument('customer', 'customer1');
-        $accounts = $customer->getAttribute('accounts', []);
-        $this->assertEquals('account1', $accounts[0]['$id']);
+        $accounts = $customer->getDocuments('accounts');
+        $this->assertEquals('account1', $accounts[0]->getId());
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer2');
-        $accounts = $customer->getAttribute('accounts', []);
-        $this->assertEquals('account2', $accounts[0]['$id']);
+        $accounts = $customer->getDocuments('accounts');
+        $this->assertEquals('account2', $accounts[0]->getId());
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer3');
-        $accounts = $customer->getAttribute('accounts', []);
-        $this->assertEquals('account3', $accounts[0]['$id']);
+        $accounts = $customer->getDocuments('accounts');
+        $this->assertEquals('account3', $accounts[0]->getId());
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer4');
-        $accounts = $customer->getAttribute('accounts', []);
-        $this->assertEquals('account4', $accounts[0]['$id']);
+        $accounts = $customer->getDocuments('accounts');
+        $this->assertEquals('account4', $accounts[0]->getId());
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         // Get related documents
         $account = $database->getDocument('account', 'account1');
-        $customer = $account->getAttribute('customer');
-        $this->assertEquals('customer1', $customer['$id']);
+        $customer = $account->getDocument('customer');
+        $this->assertEquals('customer1', $customer->getId());
         $this->assertArrayNotHasKey('accounts', $customer);
 
         $account = $database->getDocument('account', 'account2');
-        $customer = $account->getAttribute('customer');
-        $this->assertEquals('customer2', $customer['$id']);
+        $customer = $account->getDocument('customer');
+        $this->assertEquals('customer2', $customer->getId());
         $this->assertArrayNotHasKey('accounts', $customer);
 
         $account = $database->getDocument('account', 'account3');
-        $customer = $account->getAttribute('customer');
-        $this->assertEquals('customer3', $customer['$id']);
+        $customer = $account->getDocument('customer');
+        $this->assertEquals('customer3', $customer->getId());
         $this->assertArrayNotHasKey('accounts', $customer);
 
         $account = $database->getDocument('account', 'account4');
-        $customer = $account->getAttribute('customer');
-        $this->assertEquals('customer4', $customer['$id']);
+        $customer = $account->getDocument('customer');
+        $this->assertEquals('customer4', $customer->getId());
         $this->assertArrayNotHasKey('accounts', $customer);
 
         $customers = $database->find('customer');
@@ -584,22 +582,22 @@ public function testOneToManyTwoWayRelationship(): void
 
         // Select related document attributes
         $customer = $database->findOne('customer', [
-            Query::select(['*', 'accounts.name'])
+            Query::select(['*', 'accounts.name']),
         ]);
 
         if ($customer->isEmpty()) {
             throw new Exception('Customer not found');
         }
 
-        $this->assertEquals('Account 1', $customer->getAttribute('accounts')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('number', $customer->getAttribute('accounts')[0]);
+        $this->assertEquals('Account 1', $customer->getDocuments('accounts')[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('number', $customer->getDocuments('accounts')[0]);
 
         $customer = $database->getDocument('customer', 'customer1', [
-            Query::select(['*', 'accounts.name'])
+            Query::select(['*', 'accounts.name']),
         ]);
 
-        $this->assertEquals('Account 1', $customer->getAttribute('accounts')[0]->getAttribute('name'));
-        $this->assertArrayNotHasKey('number', $customer->getAttribute('accounts')[0]);
+        $this->assertEquals('Account 1', $customer->getDocuments('accounts')[0]->getAttribute('name'));
+        $this->assertArrayNotHasKey('number', $customer->getDocuments('accounts')[0]);
 
         // Update root document attribute without altering relationship
         $customer1 = $database->updateDocument(
@@ -626,7 +624,7 @@ public function testOneToManyTwoWayRelationship(): void
         $this->assertEquals('Account 2 Updated', $account2->getAttribute('name'));
 
         // Update nested document attribute
-        $accounts = $customer1->getAttribute('accounts', []);
+        $accounts = $customer1->getDocuments('accounts');
         $accounts[0]->setAttribute('name', 'Account 1 Updated');
 
         $customer1 = $database->updateDocument(
@@ -635,9 +633,9 @@ public function testOneToManyTwoWayRelationship(): void
             $customer1->setAttribute('accounts', $accounts)
         );
 
-        $this->assertEquals('Account 1 Updated', $customer1->getAttribute('accounts')[0]->getAttribute('name'));
+        $this->assertEquals('Account 1 Updated', $customer1->getDocuments('accounts')[0]->getAttribute('name'));
         $customer1 = $database->getDocument('customer', 'customer1');
-        $this->assertEquals('Account 1 Updated', $customer1->getAttribute('accounts')[0]->getAttribute('name'));
+        $this->assertEquals('Account 1 Updated', $customer1->getDocuments('accounts')[0]->getAttribute('name'));
 
         // Update inverse nested document attribute
         $account2 = $database->updateDocument(
@@ -646,14 +644,14 @@ public function testOneToManyTwoWayRelationship(): void
             $account2->setAttribute(
                 'customer',
                 $account2
-                    ->getAttribute('customer')
+                    ->getDocument('customer')
                     ->setAttribute('name', 'Customer 2 Updated')
             )
         );
 
-        $this->assertEquals('Customer 2 Updated', $account2->getAttribute('customer')->getAttribute('name'));
+        $this->assertEquals('Customer 2 Updated', $account2->getDocument('customer')->getAttribute('name'));
         $account2 = $database->getDocument('account', 'account2');
-        $this->assertEquals('Customer 2 Updated', $account2->getAttribute('customer')->getAttribute('name'));
+        $this->assertEquals('Customer 2 Updated', $account2->getDocument('customer')->getAttribute('name'));
 
         // Create new document with no relationship
         $customer5 = $database->createDocument('customer', new Document([
@@ -682,9 +680,9 @@ public function testOneToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Account 5', $customer5->getAttribute('accounts')[0]->getAttribute('name'));
+        $this->assertEquals('Account 5', $customer5->getDocuments('accounts')[0]->getAttribute('name'));
         $customer5 = $database->getDocument('customer', 'customer5');
-        $this->assertEquals('Account 5', $customer5->getAttribute('accounts')[0]->getAttribute('name'));
+        $this->assertEquals('Account 5', $customer5->getDocuments('accounts')[0]->getAttribute('name'));
 
         // Create new child document with no relationship
         $account6 = $database->createDocument('account', new Document([
@@ -713,9 +711,9 @@ public function testOneToManyTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Customer 6', $account6->getAttribute('customer')->getAttribute('name'));
+        $this->assertEquals('Customer 6', $account6->getDocument('customer')->getAttribute('name'));
         $account6 = $database->getDocument('account', 'account6');
-        $this->assertEquals('Customer 6', $account6->getAttribute('customer')->getAttribute('name'));
+        $this->assertEquals('Customer 6', $account6->getDocument('customer')->getAttribute('name'));
 
         // Update document with new related document, will remove existing relations
         $database->updateDocument(
@@ -748,13 +746,13 @@ public function testOneToManyTwoWayRelationship(): void
 
         // Get document with new relationship key
         $customer = $database->getDocument('customer', 'customer1');
-        $accounts = $customer->getAttribute('newAccounts');
-        $this->assertEquals('account1', $accounts[0]['$id']);
+        $accounts = $customer->getDocuments('newAccounts');
+        $this->assertEquals('account1', $accounts[0]->getId());
 
         // Get inverse document with new relationship key
         $account = $database->getDocument('account', 'account1');
-        $customer = $account->getAttribute('newCustomer');
-        $this->assertEquals('customer1', $customer['$id']);
+        $customer = $account->getDocument('newCustomer');
+        $this->assertEquals('customer1', $customer->getId());
 
         // Create new document with no relationship
         $database->createDocument('customer', new Document([
@@ -786,7 +784,7 @@ public function testOneToManyTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'customer',
             id: 'newAccounts',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         // Delete parent, set child relationship to null
@@ -807,7 +805,7 @@ public function testOneToManyTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'customer',
             id: 'newAccounts',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -842,34 +840,28 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('countries');
-        $database->createCollection('cities');
-        $database->createCollection('mayors');
+        $database->createCollection(new Collection(id: 'countries'));
+        $database->createCollection(new Collection(id: 'cities'));
+        $database->createCollection(new Collection(id: 'mayors'));
 
-        $database->createAttribute('cities', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('countries', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('mayors', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('cities', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('countries', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('mayors', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'countries',
-            relatedCollection: 'cities',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'country'
-        );
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(collection: 'countries', relatedCollection: 'cities', twoWay: true, twoWayKey: 'country'));
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'cities',
             relatedCollection: 'mayors',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'mayor',
+            key: 'mayor',
             twoWayKey: 'city'
-        );
+        ));
 
         $database->createDocument('countries', new Document([
             '$id' => 'country1',
@@ -913,36 +905,36 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         ]));
 
         $documents = $database->find('countries', [
-            Query::limit(1)
+            Query::limit(1),
         ]);
-        $this->assertEquals('Mayor 1', $documents[0]['cities'][0]['mayor']['name']);
+        $this->assertEquals('Mayor 1', $documents[0]->getDocuments('cities')[0]->getDocument('mayor')->getAttribute('name'));
 
         $documents = $database->find('countries', [
             Query::select(['name']),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertArrayHasKey('name', $documents[0]);
         $this->assertArrayNotHasKey('cities', $documents[0]);
 
         $documents = $database->find('countries', [
             Query::select(['*']),
-            Query::limit(1)
+            Query::limit(1),
         ]);
         $this->assertArrayHasKey('name', $documents[0]);
         $this->assertArrayNotHasKey('cities', $documents[0]);
 
         $documents = $database->find('countries', [
             Query::select(['*', 'cities.*', 'cities.mayor.*']),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
-        $this->assertEquals('Mayor 1', $documents[0]['cities'][0]['mayor']['name']);
+        $this->assertEquals('Mayor 1', $documents[0]->getDocuments('cities')[0]->getDocument('mayor')->getAttribute('name'));
 
         // Insert docs to cache:
         $country1 = $database->getDocument('countries', 'country1');
         $mayor1 = $database->getDocument('mayors', 'mayor1');
-        $this->assertEquals('City 1', $mayor1['city']['name']);
-        $this->assertEquals('City 1', $country1['cities'][0]['name']);
+        $this->assertEquals('City 1', $mayor1->getDocument('city')->getAttribute('name'));
+        $this->assertEquals('City 1', $country1->getDocuments('cities')[0]->getAttribute('name'));
 
         $database->updateDocument('cities', 'city1', new Document([
             '$id' => 'city1',
@@ -958,14 +950,14 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         $mayor1 = $database->getDocument('mayors', 'mayor1');
         $country1 = $database->getDocument('countries', 'country1');
 
-        $this->assertEquals('City 1 updated', $mayor1['city']['name']);
-        $this->assertEquals('City 1 updated', $country1['cities'][0]['name']);
-        $this->assertEquals('city1', $country1['cities'][0]['$id']);
-        $this->assertEquals('city2', $country1['cities'][1]['$id']);
-        $this->assertEquals('mayor1', $country1['cities'][0]['mayor']['$id']);
-        $this->assertEquals('mayor2', $country1['cities'][1]['mayor']['$id']);
-        $this->assertArrayNotHasKey('city', $country1['cities'][0]['mayor']);
-        $this->assertArrayNotHasKey('city', $country1['cities'][1]['mayor']);
+        $this->assertEquals('City 1 updated', $mayor1->getDocument('city')->getAttribute('name'));
+        $this->assertEquals('City 1 updated', $country1->getDocuments('cities')[0]->getAttribute('name'));
+        $this->assertEquals('city1', $country1->getDocuments('cities')[0]->getId());
+        $this->assertEquals('city2', $country1->getDocuments('cities')[1]->getId());
+        $this->assertEquals('mayor1', $country1->getDocuments('cities')[0]->getDocument('mayor')->getId());
+        $this->assertEquals('mayor2', $country1->getDocuments('cities')[1]->getDocument('mayor')->getId());
+        $this->assertArrayNotHasKey('city', $country1->getDocuments('cities')[0]->getDocument('mayor'));
+        $this->assertArrayNotHasKey('city', $country1->getDocuments('cities')[1]->getDocument('mayor'));
 
         $database->createDocument('mayors', new Document([
             '$id' => 'mayor3',
@@ -990,10 +982,10 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         ]));
 
         $country2 = $database->getDocument('countries', 'country2');
-        $this->assertEquals('city3', $country2['cities'][0]['$id']);
-        $this->assertEquals('mayor3', $country2['cities'][0]['mayor']['$id']);
-        $this->assertArrayNotHasKey('country', $country2['cities'][0]);
-        $this->assertArrayNotHasKey('city', $country2['cities'][0]['mayor']);
+        $this->assertEquals('city3', $country2->getDocuments('cities')[0]->getId());
+        $this->assertEquals('mayor3', $country2->getDocuments('cities')[0]->getDocument('mayor')->getId());
+        $this->assertArrayNotHasKey('country', $country2->getDocuments('cities')[0]);
+        $this->assertArrayNotHasKey('city', $country2->getDocuments('cities')[0]->getDocument('mayor'));
     }
 
     public function testNestedOneToMany_OneToManyRelationship(): void
@@ -1001,33 +993,22 @@ public function testNestedOneToMany_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('dormitories');
-        $database->createCollection('occupants');
-        $database->createCollection('pets');
+        $database->createCollection(new Collection(id: 'dormitories'));
+        $database->createCollection(new Collection(id: 'occupants'));
+        $database->createCollection(new Collection(id: 'pets'));
 
-        $database->createAttribute('dormitories', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('occupants', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('pets', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('dormitories', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('occupants', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('pets', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'dormitories',
-            relatedCollection: 'occupants',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'dormitory'
-        );
-        $database->createRelationship(
-            collection: 'occupants',
-            relatedCollection: 'pets',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'occupant'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'dormitories', relatedCollection: 'occupants', twoWay: true, twoWayKey: 'dormitory'));
+        $database->createRelationship(Relationship::oneToMany(collection: 'occupants', relatedCollection: 'pets', twoWay: true, twoWayKey: 'occupant'));
 
         $database->createDocument('dormitories', new Document([
             '$id' => 'dormitory1',
@@ -1086,18 +1067,18 @@ public function testNestedOneToMany_OneToManyRelationship(): void
         ]));
 
         $dormitory1 = $database->getDocument('dormitories', 'dormitory1');
-        $this->assertEquals('occupant1', $dormitory1['occupants'][0]['$id']);
-        $this->assertEquals('occupant2', $dormitory1['occupants'][1]['$id']);
-        $this->assertEquals('pet1', $dormitory1['occupants'][0]['pets'][0]['$id']);
-        $this->assertEquals('pet2', $dormitory1['occupants'][0]['pets'][1]['$id']);
-        $this->assertEquals('pet3', $dormitory1['occupants'][1]['pets'][0]['$id']);
-        $this->assertEquals('pet4', $dormitory1['occupants'][1]['pets'][1]['$id']);
-        $this->assertArrayNotHasKey('dormitory', $dormitory1['occupants'][0]);
-        $this->assertArrayNotHasKey('dormitory', $dormitory1['occupants'][1]);
-        $this->assertArrayNotHasKey('occupant', $dormitory1['occupants'][0]['pets'][0]);
-        $this->assertArrayNotHasKey('occupant', $dormitory1['occupants'][0]['pets'][1]);
-        $this->assertArrayNotHasKey('occupant', $dormitory1['occupants'][1]['pets'][0]);
-        $this->assertArrayNotHasKey('occupant', $dormitory1['occupants'][1]['pets'][1]);
+        $this->assertEquals('occupant1', $dormitory1->getDocuments('occupants')[0]->getId());
+        $this->assertEquals('occupant2', $dormitory1->getDocuments('occupants')[1]->getId());
+        $this->assertEquals('pet1', $dormitory1->getDocuments('occupants')[0]->getDocuments('pets')[0]->getId());
+        $this->assertEquals('pet2', $dormitory1->getDocuments('occupants')[0]->getDocuments('pets')[1]->getId());
+        $this->assertEquals('pet3', $dormitory1->getDocuments('occupants')[1]->getDocuments('pets')[0]->getId());
+        $this->assertEquals('pet4', $dormitory1->getDocuments('occupants')[1]->getDocuments('pets')[1]->getId());
+        $this->assertArrayNotHasKey('dormitory', $dormitory1->getDocuments('occupants')[0]);
+        $this->assertArrayNotHasKey('dormitory', $dormitory1->getDocuments('occupants')[1]);
+        $this->assertArrayNotHasKey('occupant', $dormitory1->getDocuments('occupants')[0]->getDocuments('pets')[0]);
+        $this->assertArrayNotHasKey('occupant', $dormitory1->getDocuments('occupants')[0]->getDocuments('pets')[1]);
+        $this->assertArrayNotHasKey('occupant', $dormitory1->getDocuments('occupants')[1]->getDocuments('pets')[0]);
+        $this->assertArrayNotHasKey('occupant', $dormitory1->getDocuments('occupants')[1]->getDocuments('pets')[1]);
 
         $database->createDocument('pets', new Document([
             '$id' => 'pet5',
@@ -1122,10 +1103,10 @@ public function testNestedOneToMany_OneToManyRelationship(): void
         ]));
 
         $pet5 = $database->getDocument('pets', 'pet5');
-        $this->assertEquals('occupant3', $pet5['occupant']['$id']);
-        $this->assertEquals('dormitory2', $pet5['occupant']['dormitory']['$id']);
-        $this->assertArrayNotHasKey('pets', $pet5['occupant']);
-        $this->assertArrayNotHasKey('occupant', $pet5['occupant']['dormitory']);
+        $this->assertEquals('occupant3', $pet5->getDocument('occupant')->getId());
+        $this->assertEquals('dormitory2', $pet5->getDocument('occupant')->getDocument('dormitory')->getId());
+        $this->assertArrayNotHasKey('pets', $pet5->getDocument('occupant'));
+        $this->assertArrayNotHasKey('occupant', $pet5->getDocument('occupant')->getDocument('dormitory'));
     }
 
     public function testNestedOneToMany_ManyToOneRelationship(): void
@@ -1133,32 +1114,22 @@ public function testNestedOneToMany_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('home');
-        $database->createCollection('renters');
-        $database->createCollection('floors');
+        $database->createCollection(new Collection(id: 'home'));
+        $database->createCollection(new Collection(id: 'renters'));
+        $database->createCollection(new Collection(id: 'floors'));
 
-        $database->createAttribute('home', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('renters', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('floors', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('home', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('renters', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('floors', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'home',
-            relatedCollection: 'renters',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
-        $database->createRelationship(
-            collection: 'renters',
-            relatedCollection: 'floors',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'floor'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'home', relatedCollection: 'renters', twoWay: true));
+        $database->createRelationship(Relationship::manyToOne(collection: 'renters', relatedCollection: 'floors', twoWay: true, key: 'floor'));
 
         $database->createDocument('home', new Document([
             '$id' => 'home1',
@@ -1185,10 +1156,10 @@ public function testNestedOneToMany_ManyToOneRelationship(): void
         ]));
 
         $home1 = $database->getDocument('home', 'home1');
-        $this->assertEquals('renter1', $home1['renters'][0]['$id']);
-        $this->assertEquals('floor1', $home1['renters'][0]['floor']['$id']);
-        $this->assertArrayNotHasKey('home', $home1['renters'][0]);
-        $this->assertArrayNotHasKey('renters', $home1['renters'][0]['floor']);
+        $this->assertEquals('renter1', $home1->getDocuments('renters')[0]->getId());
+        $this->assertEquals('floor1', $home1->getDocuments('renters')[0]->getDocument('floor')->getId());
+        $this->assertArrayNotHasKey('home', $home1->getDocuments('renters')[0]);
+        $this->assertArrayNotHasKey('renters', $home1->getDocuments('renters')[0]->getDocument('floor'));
 
         $database->createDocument('floors', new Document([
             '$id' => 'floor2',
@@ -1215,10 +1186,10 @@ public function testNestedOneToMany_ManyToOneRelationship(): void
         ]));
 
         $floor2 = $database->getDocument('floors', 'floor2');
-        $this->assertEquals('renter2', $floor2['renters'][0]['$id']);
-        $this->assertArrayNotHasKey('floor', $floor2['renters'][0]);
-        $this->assertEquals('home2', $floor2['renters'][0]['home']['$id']);
-        $this->assertArrayNotHasKey('renter', $floor2['renters'][0]['home']);
+        $this->assertEquals('renter2', $floor2->getDocuments('renters')[0]->getId());
+        $this->assertArrayNotHasKey('floor', $floor2->getDocuments('renters')[0]);
+        $this->assertEquals('home2', $floor2->getDocuments('renters')[0]->getDocument('home')->getId());
+        $this->assertArrayNotHasKey('renter', $floor2->getDocuments('renters')[0]->getDocument('home'));
     }
 
     public function testNestedOneToMany_ManyToManyRelationship(): void
@@ -1226,32 +1197,22 @@ public function testNestedOneToMany_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('owners');
-        $database->createCollection('cats');
-        $database->createCollection('toys');
+        $database->createCollection(new Collection(id: 'owners'));
+        $database->createCollection(new Collection(id: 'cats'));
+        $database->createCollection(new Collection(id: 'toys'));
 
-        $database->createAttribute('owners', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('cats', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('toys', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('owners', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('cats', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('toys', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'owners',
-            relatedCollection: 'cats',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'owner'
-        );
-        $database->createRelationship(
-            collection: 'cats',
-            relatedCollection: 'toys',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'owners', relatedCollection: 'cats', twoWay: true, twoWayKey: 'owner'));
+        $database->createRelationship(Relationship::manyToMany(collection: 'cats', relatedCollection: 'toys', twoWay: true));
 
         $database->createDocument('owners', new Document([
             '$id' => 'owner1',
@@ -1280,10 +1241,10 @@ public function testNestedOneToMany_ManyToManyRelationship(): void
         ]));
 
         $owner1 = $database->getDocument('owners', 'owner1');
-        $this->assertEquals('cat1', $owner1['cats'][0]['$id']);
-        $this->assertArrayNotHasKey('owner', $owner1['cats'][0]);
-        $this->assertEquals('toy1', $owner1['cats'][0]['toys'][0]['$id']);
-        $this->assertArrayNotHasKey('cats', $owner1['cats'][0]['toys'][0]);
+        $this->assertEquals('cat1', $owner1->getDocuments('cats')[0]->getId());
+        $this->assertArrayNotHasKey('owner', $owner1->getDocuments('cats')[0]);
+        $this->assertEquals('toy1', $owner1->getDocuments('cats')[0]->getDocuments('toys')[0]->getId());
+        $this->assertArrayNotHasKey('cats', $owner1->getDocuments('cats')[0]->getDocuments('toys')[0]);
 
         $database->createDocument('toys', new Document([
             '$id' => 'toy2',
@@ -1310,10 +1271,10 @@ public function testNestedOneToMany_ManyToManyRelationship(): void
         ]));
 
         $toy2 = $database->getDocument('toys', 'toy2');
-        $this->assertEquals('cat2', $toy2['cats'][0]['$id']);
-        $this->assertArrayNotHasKey('toys', $toy2['cats'][0]);
-        $this->assertEquals('owner2', $toy2['cats'][0]['owner']['$id']);
-        $this->assertArrayNotHasKey('cats', $toy2['cats'][0]['owner']);
+        $this->assertEquals('cat2', $toy2->getDocuments('cats')[0]->getId());
+        $this->assertArrayNotHasKey('toys', $toy2->getDocuments('cats')[0]);
+        $this->assertEquals('owner2', $toy2->getDocuments('cats')[0]->getDocument('owner')->getId());
+        $this->assertArrayNotHasKey('cats', $toy2->getDocuments('cats')[0]->getDocument('owner'));
     }
 
     public function testExceedMaxDepthOneToMany(): void
@@ -1321,8 +1282,9 @@ public function testExceedMaxDepthOneToMany(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1331,29 +1293,14 @@ public function testExceedMaxDepthOneToMany(): void
         $level3Collection = 'level3OneToMany';
         $level4Collection = 'level4OneToMany';
 
-        $database->createCollection($level1Collection);
-        $database->createCollection($level2Collection);
-        $database->createCollection($level3Collection);
-        $database->createCollection($level4Collection);
+        $database->createCollection(new Collection(id: $level1Collection));
+        $database->createCollection(new Collection(id: $level2Collection));
+        $database->createCollection(new Collection(id: $level3Collection));
+        $database->createCollection(new Collection(id: $level4Collection));
 
-        $database->createRelationship(
-            collection: $level1Collection,
-            relatedCollection: $level2Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level2Collection,
-            relatedCollection: $level3Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level3Collection,
-            relatedCollection: $level4Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $level1Collection, relatedCollection: $level2Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToMany(collection: $level2Collection, relatedCollection: $level3Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToMany(collection: $level3Collection, relatedCollection: $level4Collection, twoWay: true));
 
         // Exceed create depth
         $level1 = $database->createDocument($level1Collection, new Document([
@@ -1378,26 +1325,25 @@ public function testExceedMaxDepthOneToMany(): void
                 ],
             ],
         ]));
-        $this->assertEquals(1, count($level1[$level2Collection]));
-        $this->assertEquals('level2', $level1[$level2Collection][0]->getId());
-        $this->assertEquals(1, count($level1[$level2Collection][0][$level3Collection]));
-        $this->assertEquals('level3', $level1[$level2Collection][0][$level3Collection][0]->getId());
-        $this->assertArrayNotHasKey('level4', $level1[$level2Collection][0][$level3Collection][0]);
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)));
+        $this->assertEquals('level2', $level1->getDocuments($level2Collection)[0]->getId());
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)));
+        $this->assertEquals('level3', $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]->getId());
+        $this->assertArrayNotHasKey('level4', $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]);
 
         // Make sure level 4 document was not created
         $level3 = $database->getDocument($level3Collection, 'level3');
-        $this->assertEquals(0, count($level3[$level4Collection]));
+        $this->assertEquals(0, count($level3->getDocuments($level4Collection)));
         $level4 = $database->getDocument($level4Collection, 'level4');
         $this->assertTrue($level4->isEmpty());
 
         // Exceed fetch depth
         $level1 = $database->getDocument($level1Collection, 'level1');
-        $this->assertEquals(1, count($level1[$level2Collection]));
-        $this->assertEquals('level2', $level1[$level2Collection][0]->getId());
-        $this->assertEquals(1, count($level1[$level2Collection][0][$level3Collection]));
-        $this->assertEquals('level3', $level1[$level2Collection][0][$level3Collection][0]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][0][$level3Collection][0]);
-
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)));
+        $this->assertEquals('level2', $level1->getDocuments($level2Collection)[0]->getId());
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)));
+        $this->assertEquals('level3', $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]);
 
         // Exceed update depth
         $level1 = $database->updateDocument(
@@ -1418,25 +1364,27 @@ public function testExceedMaxDepthOneToMany(): void
                     ],
                 ])])
         );
-        $this->assertEquals(1, count($level1[$level2Collection]));
-        $this->assertEquals('level2new', $level1[$level2Collection][0]->getId());
-        $this->assertEquals(1, count($level1[$level2Collection][0][$level3Collection]));
-        $this->assertEquals('level3new', $level1[$level2Collection][0][$level3Collection][0]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][0][$level3Collection][0]);
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)));
+        $this->assertEquals('level2new', $level1->getDocuments($level2Collection)[0]->getId());
+        $this->assertEquals(1, count($level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)));
+        $this->assertEquals('level3new', $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]);
 
         // Make sure level 4 document was not created
         $level3 = $database->getDocument($level3Collection, 'level3new');
-        $this->assertEquals(0, count($level3[$level4Collection]));
+        $this->assertEquals(0, count($level3->getDocuments($level4Collection)));
         $level4 = $database->getDocument($level4Collection, 'level4new');
         $this->assertTrue($level4->isEmpty());
     }
+
     public function testExceedMaxDepthOneToManyChild(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1445,29 +1393,14 @@ public function testExceedMaxDepthOneToManyChild(): void
         $level3Collection = 'level3OneToManyChild';
         $level4Collection = 'level4OneToManyChild';
 
-        $database->createCollection($level1Collection);
-        $database->createCollection($level2Collection);
-        $database->createCollection($level3Collection);
-        $database->createCollection($level4Collection);
+        $database->createCollection(new Collection(id: $level1Collection));
+        $database->createCollection(new Collection(id: $level2Collection));
+        $database->createCollection(new Collection(id: $level3Collection));
+        $database->createCollection(new Collection(id: $level4Collection));
 
-        $database->createRelationship(
-            collection: $level1Collection,
-            relatedCollection: $level2Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level2Collection,
-            relatedCollection: $level3Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level3Collection,
-            relatedCollection: $level4Collection,
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $level1Collection, relatedCollection: $level2Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToMany(collection: $level2Collection, relatedCollection: $level3Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToMany(collection: $level3Collection, relatedCollection: $level4Collection, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1485,41 +1418,41 @@ public function testExceedMaxDepthOneToManyChild(): void
                                 [
                                     '$id' => 'level4',
                                 ],
-                            ]
+                            ],
                         ],
                     ],
                 ],
             ],
         ]));
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection][0]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection][0]);
-        $this->assertEquals('level3', $level1[$level2Collection][0][$level3Collection][0]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][0][$level3Collection][0]);
+        $this->assertEquals('level2', $level1->getDocuments($level2Collection)[0]->getId());
+        $this->assertArrayHasKey($level3Collection, $level1->getDocuments($level2Collection)[0]);
+        $this->assertEquals('level3', $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level1->getDocuments($level2Collection)[0]->getDocuments($level3Collection)[0]);
 
         // Confirm the 4th level document does not exist
         $level3 = $database->getDocument($level3Collection, 'level3');
-        $this->assertEquals(0, count($level3[$level4Collection]));
+        $this->assertEquals(0, count($level3->getDocuments($level4Collection)));
 
         // Create level 4 document
         $level3->setAttribute($level4Collection, [new Document([
             '$id' => 'level4',
         ])]);
         $level3 = $database->updateDocument($level3Collection, $level3->getId(), $level3);
-        $this->assertEquals('level4', $level3[$level4Collection][0]->getId());
+        $this->assertEquals('level4', $level3->getDocuments($level4Collection)[0]->getId());
 
         // Verify level 4 document is set
         $level3 = $database->getDocument($level3Collection, 'level3');
         $this->assertArrayHasKey($level4Collection, $level3);
-        $this->assertEquals('level4', $level3[$level4Collection][0]->getId());
+        $this->assertEquals('level4', $level3->getDocuments($level4Collection)[0]->getId());
 
         // Exceed fetch depth
         $level4 = $database->getDocument($level4Collection, 'level4');
         $this->assertArrayHasKey($level3Collection, $level4);
-        $this->assertEquals('level3', $level4[$level3Collection]->getId());
-        $this->assertArrayHasKey($level2Collection, $level4[$level3Collection]);
-        $this->assertEquals('level2', $level4[$level3Collection][$level2Collection]->getId());
-        $this->assertArrayNotHasKey($level1Collection, $level4[$level3Collection][$level2Collection]);
+        $this->assertEquals('level3', $level4->getDocument($level3Collection)->getId());
+        $this->assertArrayHasKey($level2Collection, $level4->getDocument($level3Collection));
+        $this->assertEquals('level2', $level4->getDocument($level3Collection)->getDocument($level2Collection)->getId());
+        $this->assertArrayNotHasKey($level1Collection, $level4->getDocument($level3Collection)->getDocument($level2Collection));
     }
 
     public function testOneToManyRelationshipKeyWithSymbols(): void
@@ -1527,42 +1460,38 @@ public function testOneToManyRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('$symbols_coll.ection3');
-        $database->createCollection('$symbols_coll.ection4');
+        $database->createCollection(new Collection(id: '$symbols_coll.ection3'));
+        $database->createCollection(new Collection(id: '$symbols_coll.ection4'));
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection3',
-            relatedCollection: '$symbols_coll.ection4',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: '$symbols_coll.ection3', relatedCollection: '$symbols_coll.ection4', twoWay: true));
 
         $doc1 = $database->createDocument('$symbols_coll.ection4', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
         $doc2 = $database->createDocument('$symbols_coll.ection3', new Document([
             '$id' => ID::unique(),
-            '$symbols_coll.ection4' => [$doc1->getId()],
+            'symbols_collection4' => [$doc1->getId()],
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
 
         $doc1 = $database->getDocument('$symbols_coll.ection4', $doc1->getId());
         $doc2 = $database->getDocument('$symbols_coll.ection3', $doc2->getId());
 
-        $this->assertEquals($doc2->getId(), $doc1->getAttribute('$symbols_coll.ection3')->getId());
-        $this->assertEquals($doc1->getId(), $doc2->getAttribute('$symbols_coll.ection4')[0]->getId());
+        $this->assertEquals($doc2->getId(), $doc1->getDocument('symbols_collection3')->getId());
+        $this->assertEquals($doc1->getId(), $doc2->getDocuments('symbols_collection4')[0]->getId());
     }
 
     public function testRecreateOneToManyOneWayRelationshipFromChild(): void
@@ -1570,65 +1499,42 @@ public function testRecreateOneToManyOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $result = $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyTwoWayRelationshipFromParent(): void
@@ -1636,67 +1542,42 @@ public function testRecreateOneToManyTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyTwoWayRelationshipFromChild(): void
@@ -1704,67 +1585,42 @@ public function testRecreateOneToManyTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyOneWayRelationshipFromParent(): void
@@ -1772,65 +1628,42 @@ public function testRecreateOneToManyOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $result = $database->createRelationship(Relationship::oneToMany(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsOneToManyRelationship(): void
@@ -1838,25 +1671,21 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->createCollection('bulk_delete_person_o2m');
-        $this->getDatabase()->createCollection('bulk_delete_library_o2m');
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_person_o2m'));
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_library_o2m'));
 
-        $this->getDatabase()->createAttribute('bulk_delete_person_o2m', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', 'area', Database::VAR_STRING, 255, true);
+        $this->getDatabase()->createAttribute('bulk_delete_person_o2m', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', Attribute::string(key: 'area', required: true));
 
         // Restrict
-        $this->getDatabase()->createRelationship(
-            collection: 'bulk_delete_person_o2m',
-            relatedCollection: 'bulk_delete_library_o2m',
-            type: Database::RELATION_ONE_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $this->getDatabase()->createRelationship(Relationship::oneToMany(collection: 'bulk_delete_person_o2m', relatedCollection: 'bulk_delete_library_o2m'));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2m', new Document([
             '$id' => 'person1',
@@ -1891,7 +1720,7 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2m', 'person1');
-        $libraries = $person1->getAttribute('bulk_delete_library_o2m');
+        $libraries = $person1->getDocuments('bulk_delete_library_o2m');
         $this->assertCount(2, $libraries);
 
         // Delete person
@@ -1913,7 +1742,7 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         $this->getDatabase()->updateRelationship(
             collection: 'bulk_delete_person_o2m',
             id: 'bulk_delete_library_o2m',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2m', new Document([
@@ -1949,26 +1778,25 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2m', 'person1');
-        $libraries = $person1->getAttribute('bulk_delete_library_o2m');
+        $libraries = $person1->getDocuments('bulk_delete_library_o2m');
         $this->assertCount(2, $libraries);
 
         $this->getDatabase()->deleteDocuments('bulk_delete_library_o2m');
         $this->assertCount(0, $this->getDatabase()->find('bulk_delete_library_o2m'));
 
         $person = $this->getDatabase()->getDocument('bulk_delete_person_o2m', 'person1');
-        $libraries = $person->getAttribute('bulk_delete_library_o2m');
+        $libraries = $person->getDocuments('bulk_delete_library_o2m');
         $this->assertEmpty($libraries);
 
         // NULL - Cleanup
         $this->getDatabase()->deleteDocuments('bulk_delete_person_o2m');
         $this->assertCount(0, $this->getDatabase()->find('bulk_delete_person_o2m'));
 
-
         // Cascade
         $this->getDatabase()->updateRelationship(
             collection: 'bulk_delete_person_o2m',
             id: 'bulk_delete_library_o2m',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2m', new Document([
@@ -2004,104 +1832,99 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2m', 'person1');
-        $libraries = $person1->getAttribute('bulk_delete_library_o2m');
+        $libraries = $person1->getDocuments('bulk_delete_library_o2m');
         $this->assertCount(2, $libraries);
 
         $this->getDatabase()->deleteDocuments('bulk_delete_library_o2m');
         $this->assertCount(0, $this->getDatabase()->find('bulk_delete_library_o2m'));
 
         $person = $this->getDatabase()->getDocument('bulk_delete_person_o2m', 'person1');
-        $libraries = $person->getAttribute('bulk_delete_library_o2m');
+        $libraries = $person->getDocuments('bulk_delete_library_o2m');
         $this->assertEmpty($libraries);
     }
 
-
     public function testOneToManyAndManyToOneDeleteRelationship(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('relation1');
-        $database->createCollection('relation2');
+        $relation1 = 'relation1_' . uniqid();
+        $relation2 = 'relation2_' . uniqid();
 
-        $database->createRelationship(
-            collection: 'relation1',
-            relatedCollection: 'relation2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createCollection(new Collection(id: $relation1));
+        $database->createCollection(new Collection(id: $relation2));
 
-        $relation1 = $database->getCollection('relation1');
-        $this->assertCount(1, $relation1->getAttribute('attributes'));
-        $this->assertCount(0, $relation1->getAttribute('indexes'));
-        $relation2 = $database->getCollection('relation2');
-        $this->assertCount(1, $relation2->getAttribute('attributes'));
-        $this->assertCount(1, $relation2->getAttribute('indexes'));
-
-        $database->deleteRelationship('relation2', 'relation1');
-
-        $relation1 = $database->getCollection('relation1');
-        $this->assertCount(0, $relation1->getAttribute('attributes'));
-        $this->assertCount(0, $relation1->getAttribute('indexes'));
-        $relation2 = $database->getCollection('relation2');
-        $this->assertCount(0, $relation2->getAttribute('attributes'));
-        $this->assertCount(0, $relation2->getAttribute('indexes'));
-
-        $database->createRelationship(
-            collection: 'relation1',
-            relatedCollection: 'relation2',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $relation1, relatedCollection: $relation2));
+
+        $relation1Col = $database->getCollection($relation1);
+        $this->assertCount(1, $relation1Col->attributes);
+        $this->assertCount(0, $relation1Col->indexes);
+        $relation2Col = $database->getCollection($relation2);
+        $this->assertCount(1, $relation2Col->attributes);
+        $this->assertCount(1, $relation2Col->indexes);
 
-        $relation1 = $database->getCollection('relation1');
-        $this->assertCount(1, $relation1->getAttribute('attributes'));
-        $this->assertCount(1, $relation1->getAttribute('indexes'));
-        $relation2 = $database->getCollection('relation2');
-        $this->assertCount(1, $relation2->getAttribute('attributes'));
-        $this->assertCount(0, $relation2->getAttribute('indexes'));
-
-        $database->deleteRelationship('relation1', 'relation2');
-
-        $relation1 = $database->getCollection('relation1');
-        $this->assertCount(0, $relation1->getAttribute('attributes'));
-        $this->assertCount(0, $relation1->getAttribute('indexes'));
-        $relation2 = $database->getCollection('relation2');
-        $this->assertCount(0, $relation2->getAttribute('attributes'));
-        $this->assertCount(0, $relation2->getAttribute('indexes'));
+        $database->deleteRelationship($relation2, $relation1);
+
+        $relation1Col = $database->getCollection($relation1);
+        $this->assertCount(0, $relation1Col->attributes);
+        $this->assertCount(0, $relation1Col->indexes);
+        $relation2Col = $database->getCollection($relation2);
+        $this->assertCount(0, $relation2Col->attributes);
+        $this->assertCount(0, $relation2Col->indexes);
+
+        $database->createRelationship(Relationship::manyToOne(collection: $relation1, relatedCollection: $relation2));
+
+        $relation1Col = $database->getCollection($relation1);
+        $this->assertCount(1, $relation1Col->attributes);
+        $this->assertCount(1, $relation1Col->indexes);
+        $relation2Col = $database->getCollection($relation2);
+        $this->assertCount(1, $relation2Col->attributes);
+        $this->assertCount(0, $relation2Col->indexes);
+
+        $database->deleteRelationship($relation1, $relation2);
+
+        $relation1Col = $database->getCollection($relation1);
+        $this->assertCount(0, $relation1Col->attributes);
+        $this->assertCount(0, $relation1Col->indexes);
+        $relation2Col = $database->getCollection($relation2);
+        $this->assertCount(0, $relation2Col->attributes);
+        $this->assertCount(0, $relation2Col->indexes);
+
+        $database->deleteCollection($relation1);
+        $database->deleteCollection($relation2);
     }
+
     public function testUpdateParentAndChild_OneToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
         if (
-            !$database->getAdapter()->getSupportForRelationships() ||
-            !$database->getAdapter()->getSupportForBatchOperations()
+            ! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_combined_o2m';
         $childCollection = 'child_combined_o2m';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
 
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'parentNumber', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::integer(key: 'parentNumber'));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $parentCollection, relatedCollection: $childCollection, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2155,30 +1978,27 @@ public function testUpdateParentAndChild_OneToMany(): void
         $database->deleteCollection($parentCollection);
         $database->deleteCollection($childCollection);
     }
+
     public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_relationship_error_one_to_many';
         $childCollection = 'child_relationship_error_one_to_many';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: $parentCollection, relatedCollection: $childCollection));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2197,8 +2017,8 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToMan
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Child 1',
-                ]
-            ]
+                ],
+            ],
         ]));
 
         try {
@@ -2220,30 +2040,32 @@ public function testPartialBatchUpdateWithRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections with relationships
-        $database->createCollection('products');
-        $database->createCollection('categories');
+        $products = 'products_' . uniqid();
+        $categories = 'categories_' . uniqid();
 
-        $database->createAttribute('products', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('products', 'price', Database::VAR_FLOAT, 0, true);
-        $database->createAttribute('categories', 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $products));
+        $database->createCollection(new Collection(id: $categories));
 
-        $database->createRelationship(
-            collection: 'categories',
-            relatedCollection: 'products',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createAttribute($products, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($products, Attribute::double(key: 'price', required: true));
+        $database->createAttribute($categories, Attribute::string(key: 'name', required: true));
+
+        $database->createRelationship(Relationship::oneToMany(
+            collection: $categories,
+            relatedCollection: $products,
             twoWay: true,
-            id: 'products',
+            key: 'products',
             twoWayKey: 'category'
-        );
+        ));
 
         // Create category with products
-        $database->createDocument('categories', new Document([
+        $database->createDocument($categories, new Document([
             '$id' => 'electronics',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -2273,51 +2095,49 @@ public function testPartialBatchUpdateWithRelationships(): void
         ]));
 
         // Verify initial state
-        $product1 = $database->getDocument('products', 'product1');
+        $product1 = $database->getDocument($products, 'product1');
         $this->assertEquals('Laptop', $product1->getAttribute('name'));
         $this->assertEquals(999.99, $product1->getAttribute('price'));
-        $this->assertEquals('electronics', $product1->getAttribute('category')->getId());
+        $this->assertEquals('electronics', $product1->getDocument('category')->getId());
 
-        $product2 = $database->getDocument('products', 'product2');
+        $product2 = $database->getDocument($products, 'product2');
         $this->assertEquals('Mouse', $product2->getAttribute('name'));
         $this->assertEquals(25.50, $product2->getAttribute('price'));
-        $this->assertEquals('electronics', $product2->getAttribute('category')->getId());
+        $this->assertEquals('electronics', $product2->getDocument('category')->getId());
 
         // Perform a BATCH partial update - ONLY update price, NOT the category relationship
-        // This is the critical test case - batch updates with relationships
         $database->updateDocuments(
-            'products',
+            $products,
             new Document([
-                'price' => 50.00, // Update price for all matching products
-                // NOTE: We deliberately do NOT include the 'category' field here - this is a partial update
+                'price' => 50.00,
             ]),
             [Query::equal('$id', ['product1', 'product2'])]
         );
 
         // Verify that prices were updated but category relationships were preserved
-        $product1After = $database->getDocument('products', 'product1');
+        $product1After = $database->getDocument($products, 'product1');
         $this->assertEquals('Laptop', $product1After->getAttribute('name'), 'Product name should be preserved');
         $this->assertEquals(50.00, $product1After->getAttribute('price'), 'Price should be updated');
 
         // This is the critical assertion - the category relationship should still exist after batch partial update
-        $categoryAfter = $product1After->getAttribute('category');
-        $this->assertNotNull($categoryAfter, 'Category relationship should be preserved after batch partial update');
+        $categoryAfter = $product1After->getDocument('category');
+        $this->assertFalse($categoryAfter->isEmpty(), 'Category relationship should be preserved after batch partial update');
         $this->assertEquals('electronics', $categoryAfter->getId(), 'Category should still be electronics');
 
-        $product2After = $database->getDocument('products', 'product2');
+        $product2After = $database->getDocument($products, 'product2');
         $this->assertEquals('Mouse', $product2After->getAttribute('name'), 'Product name should be preserved');
         $this->assertEquals(50.00, $product2After->getAttribute('price'), 'Price should be updated');
-        $this->assertEquals('electronics', $product2After->getAttribute('category')->getId(), 'Category should still be electronics');
+        $this->assertEquals('electronics', $product2After->getDocument('category')->getId(), 'Category should still be electronics');
 
         // Verify the reverse relationship is still intact
-        $category = $database->getDocument('categories', 'electronics');
-        $products = $category->getAttribute('products');
-        $this->assertCount(2, $products, 'Category should still have 2 products');
-        $this->assertEquals('product1', $products[0]->getId());
-        $this->assertEquals('product2', $products[1]->getId());
-
-        $database->deleteCollection('products');
-        $database->deleteCollection('categories');
+        $category = $database->getDocument($categories, 'electronics');
+        $productsArr = $category->getDocuments('products');
+        $this->assertCount(2, $productsArr, 'Category should still have 2 products');
+        $this->assertEquals('product1', $productsArr[0]->getId());
+        $this->assertEquals('product2', $productsArr[1]->getId());
+
+        $database->deleteCollection($products);
+        $database->deleteCollection($categories);
     }
 
     public function testPartialUpdateOnlyRelationship(): void
@@ -2325,30 +2145,32 @@ public function testPartialUpdateOnlyRelationship(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections
-        $database->createCollection('authors');
-        $database->createCollection('books');
+        $authors = 'authors_' . uniqid();
+        $books = 'books_' . uniqid();
+
+        $database->createCollection(new Collection(id: $authors));
+        $database->createCollection(new Collection(id: $books));
 
-        $database->createAttribute('authors', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('authors', 'bio', Database::VAR_STRING, 1000, false);
-        $database->createAttribute('books', 'title', Database::VAR_STRING, 255, true);
+        $database->createAttribute($authors, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($authors, Attribute::string(key: 'bio', size: 1000));
+        $database->createAttribute($books, Attribute::string(key: 'title', required: true));
 
-        $database->createRelationship(
-            collection: 'authors',
-            relatedCollection: 'books',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createRelationship(Relationship::oneToMany(
+            collection: $authors,
+            relatedCollection: $books,
             twoWay: true,
-            id: 'books',
+            key: 'books',
             twoWayKey: 'author'
-        );
+        ));
 
         // Create author with one book
-        $database->createDocument('authors', new Document([
+        $database->createDocument($authors, new Document([
             '$id' => 'author1',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -2369,7 +2191,7 @@ public function testPartialUpdateOnlyRelationship(): void
         ]));
 
         // Create a second book independently
-        $database->createDocument('books', new Document([
+        $database->createDocument($books, new Document([
             '$id' => 'book2',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -2379,19 +2201,17 @@ public function testPartialUpdateOnlyRelationship(): void
         ]));
 
         // Verify initial state
-        $author = $database->getDocument('authors', 'author1');
+        $author = $database->getDocument($authors, 'author1');
         $this->assertEquals('John Doe', $author->getAttribute('name'));
         $this->assertEquals('A great author', $author->getAttribute('bio'));
-        $this->assertCount(1, $author->getAttribute('books'));
-        $this->assertEquals('book1', $author->getAttribute('books')[0]->getId());
+        $this->assertCount(1, $author->getDocuments('books'));
+        $this->assertEquals('book1', $author->getDocuments('books')[0]->getId());
 
         // Partial update that ONLY changes the relationship (adds book2 to the author)
-        // Do NOT update name or bio
-        $database->updateDocument('authors', 'author1', new Document([
+        $database->updateDocument($authors, 'author1', new Document([
             '$id' => 'author1',
-            '$collection' => 'authors',
-            'books' => ['book1', 'book2'], // Update relationship
-            // NOTE: We deliberately do NOT include 'name' or 'bio'
+            '$collection' => $authors,
+            'books' => ['book1', 'book2'],
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
@@ -2399,24 +2219,24 @@ public function testPartialUpdateOnlyRelationship(): void
         ]));
 
         // Verify that the relationship was updated but other fields preserved
-        $authorAfter = $database->getDocument('authors', 'author1');
+        $authorAfter = $database->getDocument($authors, 'author1');
         $this->assertEquals('John Doe', $authorAfter->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals('A great author', $authorAfter->getAttribute('bio'), 'Bio should be preserved');
-        $this->assertCount(2, $authorAfter->getAttribute('books'), 'Should now have 2 books');
+        $this->assertCount(2, $authorAfter->getDocuments('books'), 'Should now have 2 books');
 
-        $bookIds = array_map(fn ($book) => $book->getId(), $authorAfter->getAttribute('books'));
+        $bookIds = \array_map(fn ($book) => $book->getId(), $authorAfter->getDocuments('books'));
         $this->assertContains('book1', $bookIds);
         $this->assertContains('book2', $bookIds);
 
         // Verify reverse relationships
-        $book1 = $database->getDocument('books', 'book1');
-        $this->assertEquals('author1', $book1->getAttribute('author')->getId());
+        $book1 = $database->getDocument($books, 'book1');
+        $this->assertEquals('author1', $book1->getDocument('author')->getId());
 
-        $book2 = $database->getDocument('books', 'book2');
-        $this->assertEquals('author1', $book2->getAttribute('author')->getId());
+        $book2 = $database->getDocument($books, 'book2');
+        $this->assertEquals('author1', $book2->getDocument('author')->getId());
 
-        $database->deleteCollection('authors');
-        $database->deleteCollection('books');
+        $database->deleteCollection($authors);
+        $database->deleteCollection($books);
     }
 
     public function testPartialUpdateBothDataAndRelationship(): void
@@ -2424,31 +2244,33 @@ public function testPartialUpdateBothDataAndRelationship(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections
-        $database->createCollection('teams');
-        $database->createCollection('players');
+        $teams = 'teams_' . uniqid();
+        $players = 'players_' . uniqid();
 
-        $database->createAttribute('teams', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('teams', 'city', Database::VAR_STRING, 255, true);
-        $database->createAttribute('teams', 'founded', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute('players', 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $teams));
+        $database->createCollection(new Collection(id: $players));
 
-        $database->createRelationship(
-            collection: 'teams',
-            relatedCollection: 'players',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createAttribute($teams, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($teams, Attribute::string(key: 'city', required: true));
+        $database->createAttribute($teams, Attribute::integer(key: 'founded'));
+        $database->createAttribute($players, Attribute::string(key: 'name', required: true));
+
+        $database->createRelationship(Relationship::oneToMany(
+            collection: $teams,
+            relatedCollection: $players,
             twoWay: true,
-            id: 'players',
+            key: 'players',
             twoWayKey: 'team'
-        );
+        ));
 
         // Create team with players
-        $database->createDocument('teams', new Document([
+        $database->createDocument($teams, new Document([
             '$id' => 'team1',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -2478,7 +2300,7 @@ public function testPartialUpdateBothDataAndRelationship(): void
         ]));
 
         // Create an additional player
-        $database->createDocument('players', new Document([
+        $database->createDocument($players, new Document([
             '$id' => 'player3',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -2488,17 +2310,17 @@ public function testPartialUpdateBothDataAndRelationship(): void
         ]));
 
         // Verify initial state
-        $team = $database->getDocument('teams', 'team1');
+        $team = $database->getDocument($teams, 'team1');
         $this->assertEquals('The Warriors', $team->getAttribute('name'));
         $this->assertEquals('San Francisco', $team->getAttribute('city'));
         $this->assertEquals(1946, $team->getAttribute('founded'));
-        $this->assertCount(2, $team->getAttribute('players'));
+        $this->assertCount(2, $team->getDocuments('players'));
 
         // Partial update that changes BOTH flat data (city) AND relationship (players)
         // Do NOT update name or founded
-        $database->updateDocument('teams', 'team1', new Document([
+        $database->updateDocument($teams, 'team1', new Document([
             '$id' => 'team1',
-            '$collection' => 'teams',
+            '$collection' => $teams,
             'city' => 'Oakland', // Update flat data
             'players' => ['player1', 'player3'], // Update relationship (replace player2 with player3)
             // NOTE: We deliberately do NOT include 'name' or 'founded'
@@ -2509,29 +2331,29 @@ public function testPartialUpdateBothDataAndRelationship(): void
         ]));
 
         // Verify that both updates worked and other fields preserved
-        $teamAfter = $database->getDocument('teams', 'team1');
+        $teamAfter = $database->getDocument($teams, 'team1');
         $this->assertEquals('The Warriors', $teamAfter->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals('Oakland', $teamAfter->getAttribute('city'), 'City should be updated');
         $this->assertEquals(1946, $teamAfter->getAttribute('founded'), 'Founded should be preserved');
-        $this->assertCount(2, $teamAfter->getAttribute('players'), 'Should still have 2 players');
+        $this->assertCount(2, $teamAfter->getDocuments('players'), 'Should still have 2 players');
 
-        $playerIds = array_map(fn ($player) => $player->getId(), $teamAfter->getAttribute('players'));
+        $playerIds = \array_map(fn ($player) => $player->getId(), $teamAfter->getDocuments('players'));
         $this->assertContains('player1', $playerIds, 'Should still have player1');
         $this->assertContains('player3', $playerIds, 'Should now have player3');
         $this->assertNotContains('player2', $playerIds, 'Should no longer have player2');
 
         // Verify reverse relationships
-        $player1 = $database->getDocument('players', 'player1');
-        $this->assertEquals('team1', $player1->getAttribute('team')->getId());
+        $player1 = $database->getDocument($players, 'player1');
+        $this->assertEquals('team1', $player1->getDocument('team')->getId());
 
-        $player2 = $database->getDocument('players', 'player2');
+        $player2 = $database->getDocument($players, 'player2');
         $this->assertNull($player2->getAttribute('team'), 'Player2 should no longer have a team');
 
-        $player3 = $database->getDocument('players', 'player3');
-        $this->assertEquals('team1', $player3->getAttribute('team')->getId());
+        $player3 = $database->getDocument($players, 'player3');
+        $this->assertEquals('team1', $player3->getDocument('team')->getId());
 
-        $database->deleteCollection('teams');
-        $database->deleteCollection('players');
+        $database->deleteCollection($teams);
+        $database->deleteCollection($players);
     }
 
     public function testPartialUpdateOneToManyChildSide(): void
@@ -2539,30 +2361,33 @@ public function testPartialUpdateOneToManyChildSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('blogs');
-        $database->createCollection('posts');
+        $blogs = 'blogs_' . uniqid();
+        $posts = 'posts_' . uniqid();
+
+        $database->createCollection(new Collection(id: $blogs));
+        $database->createCollection(new Collection(id: $posts));
 
-        $database->createAttribute('blogs', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('blogs', 'description', Database::VAR_STRING, 1000, false);
-        $database->createAttribute('posts', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('posts', 'views', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute($blogs, Attribute::string(key: 'title', required: true));
+        $database->createAttribute($blogs, Attribute::string(key: 'description', size: 1000));
+        $database->createAttribute($posts, Attribute::string(key: 'title', required: true));
+        $database->createAttribute($posts, Attribute::integer(key: 'views'));
 
-        $database->createRelationship(
-            collection: 'blogs',
-            relatedCollection: 'posts',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createRelationship(Relationship::oneToMany(
+            collection: $blogs,
+            relatedCollection: $posts,
             twoWay: true,
-            id: 'posts',
+            key: 'posts',
             twoWayKey: 'blog'
-        );
+        ));
 
         // Create blog with posts
-        $database->createDocument('blogs', new Document([
+        $database->createDocument($blogs, new Document([
             '$id' => 'blog1',
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             'title' => 'Tech Blog',
@@ -2573,20 +2398,20 @@ public function testPartialUpdateOneToManyChildSide(): void
         ]));
 
         // Partial update from child (post) side - update views only, preserve blog relationship
-        $database->updateDocument('posts', 'post1', new Document([
+        $database->updateDocument($posts, 'post1', new Document([
             '$id' => 'post1',
-            '$collection' => 'posts',
+            '$collection' => $posts,
             'views' => 200,
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
         ]));
 
-        $post = $database->getDocument('posts', 'post1');
+        $post = $database->getDocument($posts, 'post1');
         $this->assertEquals('Post 1', $post->getAttribute('title'), 'Title should be preserved');
         $this->assertEquals(200, $post->getAttribute('views'), 'Views should be updated');
-        $this->assertEquals('blog1', $post->getAttribute('blog')->getId(), 'Blog relationship should be preserved');
+        $this->assertEquals('blog1', $post->getDocument('blog')->getId(), 'Blog relationship should be preserved');
 
-        $database->deleteCollection('blogs');
-        $database->deleteCollection('posts');
+        $database->deleteCollection($blogs);
+        $database->deleteCollection($posts);
     }
 
     public function testPartialUpdateWithStringIdsVsDocuments(): void
@@ -2594,29 +2419,32 @@ public function testPartialUpdateWithStringIdsVsDocuments(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('libraries');
-        $database->createCollection('books_lib');
+        $libraries = 'libraries_' . uniqid();
+        $booksLib = 'books_lib_' . uniqid();
 
-        $database->createAttribute('libraries', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('libraries', 'location', Database::VAR_STRING, 255, false);
-        $database->createAttribute('books_lib', 'title', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $libraries));
+        $database->createCollection(new Collection(id: $booksLib));
 
-        $database->createRelationship(
-            collection: 'libraries',
-            relatedCollection: 'books_lib',
-            type: Database::RELATION_ONE_TO_MANY,
+        $database->createAttribute($libraries, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($libraries, Attribute::string(key: 'location'));
+        $database->createAttribute($booksLib, Attribute::string(key: 'title', required: true));
+
+        $database->createRelationship(Relationship::oneToMany(
+            collection: $libraries,
+            relatedCollection: $booksLib,
             twoWay: true,
-            id: 'books',
+            key: 'books',
             twoWayKey: 'library'
-        );
+        ));
 
         // Create library with books
-        $database->createDocument('libraries', new Document([
+        $database->createDocument($libraries, new Document([
             '$id' => 'lib1',
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             'name' => 'Central Library',
@@ -2627,240 +2455,53 @@ public function testPartialUpdateWithStringIdsVsDocuments(): void
         ]));
 
         // Create standalone book
-        $database->createDocument('books_lib', new Document([
+        $database->createDocument($booksLib, new Document([
             '$id' => 'book2',
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             'title' => 'Book Two',
         ]));
 
         // Partial update using STRING IDs for relationship
-        $database->updateDocument('libraries', 'lib1', new Document([
+        $database->updateDocument($libraries, 'lib1', new Document([
             '$id' => 'lib1',
-            '$collection' => 'libraries',
-            'books' => ['book1', 'book2'], // Using string IDs
+            '$collection' => $libraries,
+            'books' => ['book1', 'book2'],
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
         ]));
 
-        $lib = $database->getDocument('libraries', 'lib1');
+        $lib = $database->getDocument($libraries, 'lib1');
         $this->assertEquals('Central Library', $lib->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals('Downtown', $lib->getAttribute('location'), 'Location should be preserved');
-        $this->assertCount(2, $lib->getAttribute('books'), 'Should have 2 books');
+        $this->assertCount(2, $lib->getDocuments('books'), 'Should have 2 books');
 
         // Create another standalone book
-        $database->createDocument('books_lib', new Document([
+        $database->createDocument($booksLib, new Document([
             '$id' => 'book3',
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             'title' => 'Book Three',
         ]));
 
         // Partial update using DOCUMENT OBJECTS for relationship
-        $database->updateDocument('libraries', 'lib1', new Document([
+        $database->updateDocument($libraries, 'lib1', new Document([
             '$id' => 'lib1',
-            '$collection' => 'libraries',
-            'books' => [ // Using Document objects
+            '$collection' => $libraries,
+            'books' => [
                 new Document(['$id' => 'book1']),
                 new Document(['$id' => 'book3']),
             ],
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
         ]));
 
-        $lib = $database->getDocument('libraries', 'lib1');
+        $lib = $database->getDocument($libraries, 'lib1');
         $this->assertEquals('Central Library', $lib->getAttribute('name'), 'Name should be preserved');
         $this->assertEquals('Downtown', $lib->getAttribute('location'), 'Location should be preserved');
-        $this->assertCount(2, $lib->getAttribute('books'), 'Should have 2 books');
+        $this->assertCount(2, $lib->getDocuments('books'), 'Should have 2 books');
 
-        $bookIds = array_map(fn ($book) => $book->getId(), $lib->getAttribute('books'));
+        $bookIds = \array_map(fn ($book) => $book->getId(), $lib->getDocuments('books'));
         $this->assertContains('book1', $bookIds);
         $this->assertContains('book3', $bookIds);
 
-        $database->deleteCollection('libraries');
-        $database->deleteCollection('books_lib');
-    }
-
-    public function testOneToManyRelationshipWithArrayOperators(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if (!$database->getAdapter()->getSupportForOperators()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Cleanup any leftover collections from previous runs
-        try {
-            $database->deleteCollection('author');
-        } catch (\Throwable $e) {
-        }
-        try {
-            $database->deleteCollection('article');
-        } catch (\Throwable $e) {
-        }
-
-        $database->createCollection('author');
-        $database->createCollection('article');
-
-        $database->createAttribute('author', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('article', 'title', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'author',
-            relatedCollection: 'article',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'articles',
-            twoWayKey: 'author'
-        );
-
-        // Create some articles
-        $article1 = $database->createDocument('article', new Document([
-            '$id' => 'article1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Article 1',
-        ]));
-
-        $article2 = $database->createDocument('article', new Document([
-            '$id' => 'article2',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Article 2',
-        ]));
-
-        $article3 = $database->createDocument('article', new Document([
-            '$id' => 'article3',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Article 3',
-        ]));
-
-        // Create author with one article
-        $database->createDocument('author', new Document([
-            '$id' => 'author1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'Author 1',
-            'articles' => ['article1'],
-        ]));
-
-        // Fetch the document to get relationships (needed for Mirror which may not return relationships on create)
-        $author = $database->getDocument('author', 'author1');
-        $this->assertCount(1, $author->getAttribute('articles'));
-        $this->assertEquals('article1', $author->getAttribute('articles')[0]->getId());
-
-        // Test arrayAppend - add articles
-        $author = $database->updateDocument('author', 'author1', new Document([
-            'articles' => \Utopia\Database\Operator::arrayAppend(['article2']),
-        ]));
-
-        $author = $database->getDocument('author', 'author1');
-        $this->assertCount(2, $author->getAttribute('articles'));
-        $articleIds = \array_map(fn ($article) => $article->getId(), $author->getAttribute('articles'));
-        $this->assertContains('article1', $articleIds);
-        $this->assertContains('article2', $articleIds);
-
-        // Test arrayRemove - remove an article
-        $author = $database->updateDocument('author', 'author1', new Document([
-            'articles' => \Utopia\Database\Operator::arrayRemove('article1'),
-        ]));
-
-        $author = $database->getDocument('author', 'author1');
-        $this->assertCount(1, $author->getAttribute('articles'));
-        $articleIds = \array_map(fn ($article) => $article->getId(), $author->getAttribute('articles'));
-        $this->assertNotContains('article1', $articleIds);
-        $this->assertContains('article2', $articleIds);
-
-        // Cleanup
-        $database->deleteCollection('author');
-        $database->deleteCollection('article');
-    }
-
-    public function testOneToManyChildSideRejectsArrayOperators(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if (!$database->getAdapter()->getSupportForOperators()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Cleanup any leftover collections from previous runs
-        try {
-            $database->deleteCollection('parent_o2m');
-        } catch (\Throwable $e) {
-        }
-        try {
-            $database->deleteCollection('child_o2m');
-        } catch (\Throwable $e) {
-        }
-
-        $database->createCollection('parent_o2m');
-        $database->createCollection('child_o2m');
-
-        $database->createAttribute('parent_o2m', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('child_o2m', 'title', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'parent_o2m',
-            relatedCollection: 'child_o2m',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'children',
-            twoWayKey: 'parent'
-        );
-
-        // Create a parent
-        $database->createDocument('parent_o2m', new Document([
-            '$id' => 'parent1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'Parent 1',
-        ]));
-
-        // Create child with parent
-        $database->createDocument('child_o2m', new Document([
-            '$id' => 'child1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'title' => 'Child 1',
-            'parent' => 'parent1',
-        ]));
-
-        // Array operators should fail on child side (single-value "parent" relationship)
-        try {
-            $database->updateDocument('child_o2m', 'child1', new Document([
-                'parent' => \Utopia\Database\Operator::arrayAppend(['parent2']),
-            ]));
-            $this->fail('Expected exception for array operator on child side of one-to-many relationship');
-        } catch (\Utopia\Database\Exception\Structure $e) {
-            $this->assertStringContainsString('single-value relationship', $e->getMessage());
-        }
-
-        // Cleanup
-        $database->deleteCollection('parent_o2m');
-        $database->deleteCollection('child_o2m');
+        $database->deleteCollection($libraries);
+        $database->deleteCollection($booksLib);
     }
 }
diff --git a/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php b/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
index e67c411389..4edf621939 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
@@ -3,6 +3,10 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
@@ -14,6 +18,10 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait OneToOneTests
 {
@@ -22,37 +30,34 @@ public function testOneToOneOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('person');
-        $database->createCollection('library');
+        $database->createCollection(new Collection(id: 'person'));
+        $database->createCollection(new Collection(id: 'library'));
 
-        $database->createAttribute('person', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('library', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('library', 'area', Database::VAR_STRING, 255, true);
+        $database->createAttribute('person', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('library', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('library', Attribute::string(key: 'area', required: true));
 
-        $database->createRelationship(
-            collection: 'person',
-            relatedCollection: 'library',
-            type: Database::RELATION_ONE_TO_ONE
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'person', relatedCollection: 'library'));
 
         // Check metadata for collection
         $collection = $database->getCollection('person');
-        $attributes = $collection->getAttribute('attributes', []);
-
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'library') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('library', $attribute['$id']);
-                $this->assertEquals('library', $attribute['key']);
-                $this->assertEquals('library', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(false, $attribute['options']['twoWay']);
-                $this->assertEquals('person', $attribute['options']['twoWayKey']);
+
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'library') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('library', $attribute->getId());
+                $this->assertEquals('library', $attribute->key);
+                $this->assertEquals('library', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(false, $options['twoWay'] ?? null);
+                $this->assertEquals('person', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -125,7 +130,7 @@ public function testOneToOneOneWayRelationship(): void
                 'area' => 'Area 10 Updated',
             ],
         ]));
-        $this->assertEquals('Library 10 Updated', $person10->getAttribute('library')->getAttribute('name'));
+        $this->assertEquals('Library 10 Updated', $person10->getDocument('library')->getAttribute('name'));
         $library10 = $database->getDocument('library', $library10->getId());
         $this->assertEquals('Library 10 Updated', $library10->getAttribute('name'));
 
@@ -152,13 +157,13 @@ public function testOneToOneOneWayRelationship(): void
 
         // Get documents with relationship
         $person1 = $database->getDocument('person', 'person1');
-        $library = $person1->getAttribute('library');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('library');
+        $this->assertEquals('library1', $library->getId());
         $this->assertArrayNotHasKey('person', $library);
 
         $person = $database->getDocument('person', 'person2');
-        $library = $person->getAttribute('library');
-        $this->assertEquals('library2', $library['$id']);
+        $library = $person->getDocument('library');
+        $this->assertEquals('library2', $library->getId());
         $this->assertArrayNotHasKey('person', $library);
 
         // Get related documents
@@ -169,7 +174,7 @@ public function testOneToOneOneWayRelationship(): void
         $this->assertArrayNotHasKey('person', $library);
 
         $people = $database->find('person', [
-            Query::select(['name'])
+            Query::select(['name']),
         ]);
 
         $this->assertArrayNotHasKey('library', $people[0]);
@@ -179,24 +184,22 @@ public function testOneToOneOneWayRelationship(): void
 
         // Select related document attributes
         $person = $database->findOne('person', [
-            Query::select(['*', 'library.name'])
+            Query::select(['*', 'library.name']),
         ]);
 
         if ($person->isEmpty()) {
             throw new Exception('Person not found');
         }
 
-        $this->assertEquals('Library 1', $person->getAttribute('library')->getAttribute('name'));
-        $this->assertArrayNotHasKey('area', $person->getAttribute('library'));
+        $this->assertEquals('Library 1', $person->getDocument('library')->getAttribute('name'));
+        $this->assertArrayNotHasKey('area', $person->getDocument('library'));
 
         $person = $database->getDocument('person', 'person1', [
-            Query::select(['*', 'library.name', '$id'])
+            Query::select(['*', 'library.name', '$id']),
         ]);
 
-        $this->assertEquals('Library 1', $person->getAttribute('library')->getAttribute('name'));
-        $this->assertArrayNotHasKey('area', $person->getAttribute('library'));
-
-
+        $this->assertEquals('Library 1', $person->getDocument('library')->getAttribute('name'));
+        $this->assertArrayNotHasKey('area', $person->getDocument('library'));
 
         $document = $database->getDocument('person', $person->getId(), [
             Query::select(['name']),
@@ -212,7 +215,7 @@ public function testOneToOneOneWayRelationship(): void
         $document = $database->getDocument('person', $person->getId(), [
             Query::select(['library.*']),
         ]);
-        $this->assertEquals('Library 1', $document['library']['name']);
+        $this->assertEquals('Library 1', $document->getDocument('library')->getAttribute('name'));
         $this->assertArrayNotHasKey('name', $document);
 
         // Update root document attribute without altering relationship
@@ -233,14 +236,14 @@ public function testOneToOneOneWayRelationship(): void
             $person1->setAttribute(
                 'library',
                 $person1
-                    ->getAttribute('library')
+                    ->getDocument('library')
                     ->setAttribute('name', 'Library 1 Updated')
             )
         );
 
-        $this->assertEquals('Library 1 Updated', $person1->getAttribute('library')->getAttribute('name'));
+        $this->assertEquals('Library 1 Updated', $person1->getDocument('library')->getAttribute('name'));
         $person1 = $database->getDocument('person', 'person1');
-        $this->assertEquals('Library 1 Updated', $person1->getAttribute('library')->getAttribute('name'));
+        $this->assertEquals('Library 1 Updated', $person1->getDocument('library')->getAttribute('name'));
 
         // Create new document with no relationship
         $person3 = $database->createDocument('person', new Document([
@@ -268,9 +271,9 @@ public function testOneToOneOneWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('library3', $person3->getAttribute('library')['$id']);
+        $this->assertEquals('library3', $person3->getDocument('library')->getId());
         $person3 = $database->getDocument('person', 'person3');
-        $this->assertEquals('Library 3', $person3['library']['name']);
+        $this->assertEquals('Library 3', $person3->getDocument('library')->getAttribute('name'));
 
         $libraryDocument = $database->getDocument('library', 'library3');
         $libraryDocument->setAttribute('name', 'Library 3 updated');
@@ -280,8 +283,8 @@ public function testOneToOneOneWayRelationship(): void
 
         $person3 = $database->getDocument('person', 'person3');
         // Todo: This is failing
-        $this->assertEquals($libraryDocument['name'], $person3['library']['name']);
-        $this->assertEquals('library3', $person3->getAttribute('library')['$id']);
+        $this->assertEquals($libraryDocument->getAttribute('name'), $person3->getDocument('library')->getAttribute('name'));
+        $this->assertEquals('library3', $person3->getDocument('library')->getId());
 
         // One to one can't relate to multiple documents, unique index throws duplicate
         try {
@@ -329,8 +332,8 @@ public function testOneToOneOneWayRelationship(): void
 
         // Get document with again
         $person = $database->getDocument('person', 'person1');
-        $library = $person->getAttribute('newLibrary');
-        $this->assertEquals('library4', $library['$id']);
+        $library = $person->getDocument('newLibrary');
+        $this->assertEquals('library4', $library->getId());
 
         // Create person with no relationship
         $database->createDocument('person', new Document([
@@ -386,7 +389,7 @@ public function testOneToOneOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'person',
             id: 'newLibrary',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         // Delete parent, no effect on children for one-way
@@ -410,7 +413,7 @@ public function testOneToOneOneWayRelationship(): void
         $database->updateRelationship(
             collection: 'person',
             id: 'newLibrary',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -447,50 +450,46 @@ public function testOneToOneTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('country');
-        $database->createCollection('city');
+        $database->createCollection(new Collection(id: 'country'));
+        $database->createCollection(new Collection(id: 'city'));
 
-        $database->createAttribute('country', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('city', 'code', Database::VAR_STRING, 3, true);
-        $database->createAttribute('city', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('country', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('city', Attribute::string(key: 'code', size: 3, required: true));
+        $database->createAttribute('city', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: 'country',
-            relatedCollection: 'city',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'country', relatedCollection: 'city', twoWay: true));
 
         $collection = $database->getCollection('country');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'city') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('city', $attribute['$id']);
-                $this->assertEquals('city', $attribute['key']);
-                $this->assertEquals('city', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('country', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'city') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('city', $attribute->getId());
+                $this->assertEquals('city', $attribute->key);
+                $this->assertEquals('city', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('country', $options['twoWayKey'] ?? null);
             }
         }
 
         $collection = $database->getCollection('city');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'country') {
-                $this->assertEquals('relationship', $attribute['type']);
-                $this->assertEquals('country', $attribute['$id']);
-                $this->assertEquals('country', $attribute['key']);
-                $this->assertEquals('country', $attribute['options']['relatedCollection']);
-                $this->assertEquals(Database::RELATION_ONE_TO_ONE, $attribute['options']['relationType']);
-                $this->assertEquals(true, $attribute['options']['twoWay']);
-                $this->assertEquals('city', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            if ($attribute->key === 'country') {
+                $options = $attribute->options ?? [];
+                $this->assertEquals(ColumnType::Relationship, $attribute->type);
+                $this->assertEquals('country', $attribute->getId());
+                $this->assertEquals('country', $attribute->key);
+                $this->assertEquals('country', $options['relatedCollection'] ?? null);
+                $this->assertEquals(RelationType::OneToOne->value, $options['relationType'] ?? null);
+                $this->assertEquals(true, $options['twoWay'] ?? null);
+                $this->assertEquals('city', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -517,7 +516,7 @@ public function testOneToOneTwoWayRelationship(): void
 
         $database->createDocument('country', new Document($doc->getArrayCopy()));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('London', $country1->getAttribute('city')->getAttribute('name'));
+        $this->assertEquals('London', $country1->getDocument('city')->getAttribute('name'));
 
         // Update a document with non existing related document. It should not get added to the list.
         $database->updateDocument('country', 'country1', (new Document($doc->getArrayCopy()))->setAttribute('city', 'no-city'));
@@ -539,13 +538,13 @@ public function testOneToOneTwoWayRelationship(): void
         $this->assertTrue($city1->isEmpty());
 
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertTrue($country1->getAttribute('city')->isEmpty());
+        $this->assertTrue($country1->getDocument('city')->isEmpty());
 
         $this->assertTrue($database->deleteDocument('country', 'country1'));
 
         $database->createDocument('country', new Document($doc->getArrayCopy()));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('London', $country1->getAttribute('city')->getAttribute('name'));
+        $this->assertEquals('London', $country1->getDocument('city')->getAttribute('name'));
 
         // Create document with relationship with related ID
         $database->createDocument('city', new Document([
@@ -612,44 +611,44 @@ public function testOneToOneTwoWayRelationship(): void
 
         // Get document with relationship
         $city = $database->getDocument('city', 'city1');
-        $country = $city->getAttribute('country');
-        $this->assertEquals('country1', $country['$id']);
+        $country = $city->getDocument('country');
+        $this->assertEquals('country1', $country->getId());
         $this->assertArrayNotHasKey('city', $country);
 
         $city = $database->getDocument('city', 'city2');
-        $country = $city->getAttribute('country');
-        $this->assertEquals('country2', $country['$id']);
+        $country = $city->getDocument('country');
+        $this->assertEquals('country2', $country->getId());
         $this->assertArrayNotHasKey('city', $country);
 
         $city = $database->getDocument('city', 'city3');
-        $country = $city->getAttribute('country');
-        $this->assertEquals('country3', $country['$id']);
+        $country = $city->getDocument('country');
+        $this->assertEquals('country3', $country->getId());
         $this->assertArrayNotHasKey('city', $country);
 
         $city = $database->getDocument('city', 'city4');
-        $country = $city->getAttribute('country');
-        $this->assertEquals('country4', $country['$id']);
+        $country = $city->getDocument('country');
+        $this->assertEquals('country4', $country->getId());
         $this->assertArrayNotHasKey('city', $country);
 
         // Get inverse document with relationship
         $country = $database->getDocument('country', 'country1');
-        $city = $country->getAttribute('city');
-        $this->assertEquals('city1', $city['$id']);
+        $city = $country->getDocument('city');
+        $this->assertEquals('city1', $city->getId());
         $this->assertArrayNotHasKey('country', $city);
 
         $country = $database->getDocument('country', 'country2');
-        $city = $country->getAttribute('city');
-        $this->assertEquals('city2', $city['$id']);
+        $city = $country->getDocument('city');
+        $this->assertEquals('city2', $city->getId());
         $this->assertArrayNotHasKey('country', $city);
 
         $country = $database->getDocument('country', 'country3');
-        $city = $country->getAttribute('city');
-        $this->assertEquals('city3', $city['$id']);
+        $city = $country->getDocument('city');
+        $this->assertEquals('city3', $city->getId());
         $this->assertArrayNotHasKey('country', $city);
 
         $country = $database->getDocument('country', 'country4');
-        $city = $country->getAttribute('city');
-        $this->assertEquals('city4', $city['$id']);
+        $city = $country->getDocument('city');
+        $this->assertEquals('city4', $city->getId());
         $this->assertArrayNotHasKey('country', $city);
 
         $countries = $database->find('country');
@@ -658,22 +657,22 @@ public function testOneToOneTwoWayRelationship(): void
 
         // Select related document attributes
         $country = $database->findOne('country', [
-            Query::select(['*', 'city.name'])
+            Query::select(['*', 'city.name']),
         ]);
 
         if ($country->isEmpty()) {
             throw new Exception('Country not found');
         }
 
-        $this->assertEquals('London', $country->getAttribute('city')->getAttribute('name'));
-        $this->assertArrayNotHasKey('code', $country->getAttribute('city'));
+        $this->assertEquals('London', $country->getDocument('city')->getAttribute('name'));
+        $this->assertArrayNotHasKey('code', $country->getDocument('city'));
 
         $country = $database->getDocument('country', 'country1', [
-            Query::select(['*', 'city.name'])
+            Query::select(['*', 'city.name']),
         ]);
 
-        $this->assertEquals('London', $country->getAttribute('city')->getAttribute('name'));
-        $this->assertArrayNotHasKey('code', $country->getAttribute('city'));
+        $this->assertEquals('London', $country->getDocument('city')->getAttribute('name'));
+        $this->assertArrayNotHasKey('code', $country->getDocument('city'));
 
         $country1 = $database->getDocument('country', 'country1');
 
@@ -708,14 +707,14 @@ public function testOneToOneTwoWayRelationship(): void
             $country1->setAttribute(
                 'city',
                 $country1
-                    ->getAttribute('city')
+                    ->getDocument('city')
                     ->setAttribute('name', 'City 1 Updated')
             )
         );
 
-        $this->assertEquals('City 1 Updated', $country1->getAttribute('city')->getAttribute('name'));
+        $this->assertEquals('City 1 Updated', $country1->getDocument('city')->getAttribute('name'));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('City 1 Updated', $country1->getAttribute('city')->getAttribute('name'));
+        $this->assertEquals('City 1 Updated', $country1->getDocument('city')->getAttribute('name'));
 
         // Update inverse nested document attribute
         $city2 = $database->updateDocument(
@@ -724,14 +723,14 @@ public function testOneToOneTwoWayRelationship(): void
             $city2->setAttribute(
                 'country',
                 $city2
-                    ->getAttribute('country')
+                    ->getDocument('country')
                     ->setAttribute('name', 'Country 2 Updated')
             )
         );
 
-        $this->assertEquals('Country 2 Updated', $city2->getAttribute('country')->getAttribute('name'));
+        $this->assertEquals('Country 2 Updated', $city2->getDocument('country')->getAttribute('name'));
         $city2 = $database->getDocument('city', 'city2');
-        $this->assertEquals('Country 2 Updated', $city2->getAttribute('country')->getAttribute('name'));
+        $this->assertEquals('Country 2 Updated', $city2->getDocument('country')->getAttribute('name'));
 
         // Create new document with no relationship
         $country5 = $database->createDocument('country', new Document([
@@ -759,9 +758,9 @@ public function testOneToOneTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('city5', $country5->getAttribute('city')['$id']);
+        $this->assertEquals('city5', $country5->getDocument('city')->getId());
         $country5 = $database->getDocument('country', 'country5');
-        $this->assertEquals('city5', $country5->getAttribute('city')['$id']);
+        $this->assertEquals('city5', $country5->getDocument('city')->getId());
 
         // Create new document with no relationship
         $city6 = $database->createDocument('city', new Document([
@@ -789,9 +788,9 @@ public function testOneToOneTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('country6', $city6->getAttribute('country')['$id']);
+        $this->assertEquals('country6', $city6->getDocument('country')->getId());
         $city6 = $database->getDocument('city', 'city6');
-        $this->assertEquals('country6', $city6->getAttribute('country')['$id']);
+        $this->assertEquals('country6', $city6->getDocument('country')->getId());
 
         // One to one can't relate to multiple documents, unique index throws duplicate
         try {
@@ -852,7 +851,7 @@ public function testOneToOneTwoWayRelationship(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Denmark'
+            'name' => 'Denmark',
         ]));
 
         // Update inverse document with new related document
@@ -872,13 +871,13 @@ public function testOneToOneTwoWayRelationship(): void
 
         // Get document with new relationship key
         $city = $database->getDocument('city', 'city1');
-        $country = $city->getAttribute('newCountry');
-        $this->assertEquals('country7', $country['$id']);
+        $country = $city->getDocument('newCountry');
+        $this->assertEquals('country7', $country->getId());
 
         // Get inverse document with new relationship key
         $country = $database->getDocument('country', 'country7');
-        $city = $country->getAttribute('newCity');
-        $this->assertEquals('city1', $city['$id']);
+        $city = $country->getDocument('newCity');
+        $this->assertEquals('city1', $city->getId());
 
         // Create a new country with no relation
         $database->createDocument('country', new Document([
@@ -888,7 +887,7 @@ public function testOneToOneTwoWayRelationship(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Denmark'
+            'name' => 'Denmark',
         ]));
 
         // Can delete parent document with no relation with on delete set to restrict
@@ -898,7 +897,6 @@ public function testOneToOneTwoWayRelationship(): void
         $country8 = $database->getDocument('country', 'country8');
         $this->assertEquals(true, $country8->isEmpty());
 
-
         // Cannot delete document while still related to another with on delete set to restrict
         try {
             $database->deleteDocument('country', 'country1');
@@ -911,14 +909,14 @@ public function testOneToOneTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'country',
             id: 'newCity',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         $database->updateDocument('city', 'city1', new Document(['newCountry' => null, '$id' => 'city1']));
         $city1 = $database->getDocument('city', 'city1');
         $this->assertNull($city1->getAttribute('newCountry'));
 
-        // Check Delete TwoWay TRUE && RELATION_MUTATE_SET_NULL && related value NULL
+        // Check Delete TwoWay TRUE && ForeignKeyAction::SetNull && related value NULL
         $this->assertTrue($database->deleteDocument('city', 'city1'));
         $city1 = $database->getDocument('city', 'city1');
         $this->assertTrue($city1->isEmpty());
@@ -948,7 +946,7 @@ public function testOneToOneTwoWayRelationship(): void
         $database->updateRelationship(
             collection: 'country',
             id: 'newCity',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         // Delete parent, will delete child
@@ -983,8 +981,8 @@ public function testOneToOneTwoWayRelationship(): void
             'code' => 'MUC',
             'newCountry' => [
                 '$id' => 'country7',
-                'name' => 'Germany'
-            ]
+                'name' => 'Germany',
+            ],
         ]));
 
         // Delete relationship
@@ -1009,50 +1007,35 @@ public function testIdenticalTwoWayKeyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('parent');
-        $database->createCollection('child');
+        $database->createCollection(new Collection(id: 'parent'));
+        $database->createCollection(new Collection(id: 'child'));
 
-        $database->createRelationship(
-            collection: 'parent',
-            relatedCollection: 'child',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'child1'
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'parent', relatedCollection: 'child', key: 'child1'));
 
         try {
-            $database->createRelationship(
-                collection: 'parent',
-                relatedCollection: 'child',
-                type: Database::RELATION_ONE_TO_MANY,
-                id: 'children',
-            );
+            $database->createRelationship(Relationship::oneToMany(collection: 'parent', relatedCollection: 'child', key: 'children'));
             $this->fail('Failed to throw Exception');
         } catch (Exception $e) {
             $this->assertEquals('Related attribute already exists', $e->getMessage());
         }
 
-        $database->createRelationship(
-            collection: 'parent',
-            relatedCollection: 'child',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'children',
-            twoWayKey: 'parent_id'
-        );
+        $database->createRelationship(Relationship::oneToMany(collection: 'parent', relatedCollection: 'child', key: 'children', twoWayKey: 'parent_id'));
 
         $collection = $database->getCollection('parent');
-        $attributes = $collection->getAttribute('attributes', []);
-        foreach ($attributes as $attribute) {
-            if ($attribute['key'] === 'child1') {
-                $this->assertEquals('parent', $attribute['options']['twoWayKey']);
+        foreach ($collection->attributes as $attribute) {
+            $options = $attribute->options ?? [];
+            if ($attribute->key === 'child1') {
+                $this->assertEquals('parent', $options['twoWayKey'] ?? null);
             }
 
-            if ($attribute['key'] === 'children') {
-                $this->assertEquals('parent_id', $attribute['options']['twoWayKey']);
+            if ($attribute->key === 'children') {
+                $this->assertEquals('parent_id', $options['twoWayKey'] ?? null);
             }
         }
 
@@ -1075,11 +1058,14 @@ public function testIdenticalTwoWayKeyRelationship(): void
         ]));
 
         $documents = $database->find('parent', []);
-        $document  = array_pop($documents);
+        $document = array_pop($documents);
+        $this->assertInstanceOf(Document::class, $document);
         $this->assertArrayHasKey('child1', $document);
-        $this->assertEquals('foo', $document->getAttribute('child1')->getId());
+        $this->assertEquals('foo', $document->getDocument('child1')->getId());
         $this->assertArrayHasKey('children', $document);
-        $this->assertEquals('bar', $document->getAttribute('children')[0]->getId());
+        $children = $document->getDocuments('children');
+        $this->assertNotEmpty($children);
+        $this->assertEquals('bar', $children[0]->getId());
 
         try {
             $database->updateRelationship(
@@ -1109,35 +1095,34 @@ public function testNestedOneToOne_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('pattern');
-        $database->createCollection('shirt');
-        $database->createCollection('team');
+        $database->createCollection(new Collection(id: 'pattern'));
+        $database->createCollection(new Collection(id: 'shirt'));
+        $database->createCollection(new Collection(id: 'team'));
 
-        $database->createAttribute('pattern', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('shirt', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('team', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('pattern', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('shirt', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('team', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'pattern',
             relatedCollection: 'shirt',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'shirt',
+            key: 'shirt',
             twoWayKey: 'pattern'
-        );
-        $database->createRelationship(
+        ));
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'shirt',
             relatedCollection: 'team',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'team',
+            key: 'team',
             twoWayKey: 'shirt'
-        );
+        ));
 
         $database->createDocument('pattern', new Document([
             '$id' => 'stripes',
@@ -1162,10 +1147,12 @@ public function testNestedOneToOne_OneToOneRelationship(): void
         ]));
 
         $pattern = $database->getDocument('pattern', 'stripes');
-        $this->assertEquals('red', $pattern['shirt']['$id']);
-        $this->assertArrayNotHasKey('pattern', $pattern['shirt']);
-        $this->assertEquals('reds', $pattern['shirt']['team']['$id']);
-        $this->assertArrayNotHasKey('shirt', $pattern['shirt']['team']);
+        $shirt = $pattern->getDocument('shirt');
+        $this->assertEquals('red', $shirt->getId());
+        $this->assertArrayNotHasKey('pattern', $shirt);
+        $team = $shirt->getDocument('team');
+        $this->assertEquals('reds', $team->getId());
+        $this->assertArrayNotHasKey('shirt', $team);
 
         $database->createDocument('team', new Document([
             '$id' => 'blues',
@@ -1190,10 +1177,12 @@ public function testNestedOneToOne_OneToOneRelationship(): void
         ]));
 
         $team = $database->getDocument('team', 'blues');
-        $this->assertEquals('blue', $team['shirt']['$id']);
-        $this->assertArrayNotHasKey('team', $team['shirt']);
-        $this->assertEquals('plain', $team['shirt']['pattern']['$id']);
-        $this->assertArrayNotHasKey('shirt', $team['shirt']['pattern']);
+        $shirt = $team->getDocument('shirt');
+        $this->assertEquals('blue', $shirt->getId());
+        $this->assertArrayNotHasKey('team', $shirt);
+        $pattern = $shirt->getDocument('pattern');
+        $this->assertEquals('plain', $pattern->getId());
+        $this->assertArrayNotHasKey('shirt', $pattern);
     }
 
     public function testNestedOneToOne_OneToManyRelationship(): void
@@ -1201,34 +1190,28 @@ public function testNestedOneToOne_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('teachers');
-        $database->createCollection('classrooms');
-        $database->createCollection('children');
+        $database->createCollection(new Collection(id: 'teachers'));
+        $database->createCollection(new Collection(id: 'classrooms'));
+        $database->createCollection(new Collection(id: 'children'));
 
-        $database->createAttribute('children', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('teachers', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('classrooms', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('children', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('teachers', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('classrooms', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'teachers',
             relatedCollection: 'classrooms',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'classroom',
+            key: 'classroom',
             twoWayKey: 'teacher'
-        );
-        $database->createRelationship(
-            collection: 'classrooms',
-            relatedCollection: 'children',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'classroom'
-        );
+        ));
+        $database->createRelationship(Relationship::oneToMany(collection: 'classrooms', relatedCollection: 'children', twoWay: true, twoWayKey: 'classroom'));
 
         $database->createDocument('teachers', new Document([
             '$id' => 'teacher1',
@@ -1262,11 +1245,13 @@ public function testNestedOneToOne_OneToManyRelationship(): void
         ]));
 
         $teacher1 = $database->getDocument('teachers', 'teacher1');
-        $this->assertEquals('classroom1', $teacher1['classroom']['$id']);
-        $this->assertArrayNotHasKey('teacher', $teacher1['classroom']);
-        $this->assertEquals(2, \count($teacher1['classroom']['children']));
-        $this->assertEquals('Child 1', $teacher1['classroom']['children'][0]['name']);
-        $this->assertEquals('Child 2', $teacher1['classroom']['children'][1]['name']);
+        $classroom = $teacher1->getDocument('classroom');
+        $this->assertEquals('classroom1', $classroom->getId());
+        $this->assertArrayNotHasKey('teacher', $classroom);
+        $children = $classroom->getDocuments('children');
+        $this->assertCount(2, $children);
+        $this->assertEquals('Child 1', $children[0]->getAttribute('name'));
+        $this->assertEquals('Child 2', $children[1]->getAttribute('name'));
 
         $database->createDocument('children', new Document([
             '$id' => 'child3',
@@ -1291,10 +1276,12 @@ public function testNestedOneToOne_OneToManyRelationship(): void
         ]));
 
         $child3 = $database->getDocument('children', 'child3');
-        $this->assertEquals('classroom2', $child3['classroom']['$id']);
-        $this->assertArrayNotHasKey('children', $child3['classroom']);
-        $this->assertEquals('teacher2', $child3['classroom']['teacher']['$id']);
-        $this->assertArrayNotHasKey('classroom', $child3['classroom']['teacher']);
+        $classroom = $child3->getDocument('classroom');
+        $this->assertEquals('classroom2', $classroom->getId());
+        $this->assertArrayNotHasKey('children', $classroom);
+        $teacher = $classroom->getDocument('teacher');
+        $this->assertEquals('teacher2', $teacher->getId());
+        $this->assertArrayNotHasKey('classroom', $teacher);
     }
 
     public function testNestedOneToOne_ManyToOneRelationship(): void
@@ -1302,34 +1289,28 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('users');
-        $database->createCollection('profiles');
-        $database->createCollection('avatars');
+        $database->createCollection(new Collection(id: 'users'));
+        $database->createCollection(new Collection(id: 'profiles'));
+        $database->createCollection(new Collection(id: 'avatars'));
 
-        $database->createAttribute('users', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profiles', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('avatars', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('users', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('profiles', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('avatars', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'users',
             relatedCollection: 'profiles',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'profile',
+            key: 'profile',
             twoWayKey: 'user'
-        );
-        $database->createRelationship(
-            collection: 'profiles',
-            relatedCollection: 'avatars',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'avatar',
-        );
+        ));
+        $database->createRelationship(Relationship::manyToOne(collection: 'profiles', relatedCollection: 'avatars', twoWay: true, key: 'avatar'));
 
         $database->createDocument('users', new Document([
             '$id' => 'user1',
@@ -1354,10 +1335,12 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
         ]));
 
         $user1 = $database->getDocument('users', 'user1');
-        $this->assertEquals('profile1', $user1['profile']['$id']);
-        $this->assertArrayNotHasKey('user', $user1['profile']);
-        $this->assertEquals('avatar1', $user1['profile']['avatar']['$id']);
-        $this->assertArrayNotHasKey('profile', $user1['profile']['avatar']);
+        $profile = $user1->getDocument('profile');
+        $this->assertEquals('profile1', $profile->getId());
+        $this->assertArrayNotHasKey('user', $profile);
+        $avatar = $profile->getDocument('avatar');
+        $this->assertEquals('avatar1', $avatar->getId());
+        $this->assertArrayNotHasKey('profile', $avatar);
 
         $database->createDocument('avatars', new Document([
             '$id' => 'avatar2',
@@ -1379,15 +1362,17 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
                         ],
                         'name' => 'User 2',
                     ],
-                ]
+                ],
             ],
         ]));
 
         $avatar2 = $database->getDocument('avatars', 'avatar2');
-        $this->assertEquals('profile2', $avatar2['profiles'][0]['$id']);
-        $this->assertArrayNotHasKey('avatars', $avatar2['profiles'][0]);
-        $this->assertEquals('user2', $avatar2['profiles'][0]['user']['$id']);
-        $this->assertArrayNotHasKey('profiles', $avatar2['profiles'][0]['user']);
+        $profiles = $avatar2->getDocuments('profiles');
+        $this->assertNotEmpty($profiles);
+        $this->assertEquals('profile2', $profiles[0]->getId());
+        $this->assertArrayNotHasKey('avatars', $profiles[0]);
+        $this->assertEquals('user2', $profiles[0]->getDocument('user')->getId());
+        $this->assertArrayNotHasKey('profiles', $profiles[0]->getDocument('user'));
     }
 
     public function testNestedOneToOne_ManyToManyRelationship(): void
@@ -1395,33 +1380,28 @@ public function testNestedOneToOne_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('addresses');
-        $database->createCollection('houses');
-        $database->createCollection('buildings');
+        $database->createCollection(new Collection(id: 'addresses'));
+        $database->createCollection(new Collection(id: 'houses'));
+        $database->createCollection(new Collection(id: 'buildings'));
 
-        $database->createAttribute('addresses', 'street', Database::VAR_STRING, 255, true);
-        $database->createAttribute('houses', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('buildings', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('addresses', Attribute::string(key: 'street', required: true));
+        $database->createAttribute('houses', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('buildings', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'addresses',
             relatedCollection: 'houses',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'house',
+            key: 'house',
             twoWayKey: 'address'
-        );
-        $database->createRelationship(
-            collection: 'houses',
-            relatedCollection: 'buildings',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        ));
+        $database->createRelationship(Relationship::manyToMany(collection: 'houses', relatedCollection: 'buildings', twoWay: true));
 
         $database->createDocument('addresses', new Document([
             '$id' => 'address1',
@@ -1455,12 +1435,15 @@ public function testNestedOneToOne_ManyToManyRelationship(): void
         ]));
 
         $address1 = $database->getDocument('addresses', 'address1');
-        $this->assertEquals('house1', $address1['house']['$id']);
-        $this->assertArrayNotHasKey('address', $address1['house']);
-        $this->assertEquals('building1', $address1['house']['buildings'][0]['$id']);
-        $this->assertEquals('building2', $address1['house']['buildings'][1]['$id']);
-        $this->assertArrayNotHasKey('houses', $address1['house']['buildings'][0]);
-        $this->assertArrayNotHasKey('houses', $address1['house']['buildings'][1]);
+        $house = $address1->getDocument('house');
+        $this->assertSame('house1', $house->getId());
+        $this->assertArrayNotHasKey('address', $house);
+        $buildings = $house->getDocuments('buildings');
+        $this->assertCount(2, $buildings);
+        $this->assertSame('building1', $buildings[0]->getId());
+        $this->assertSame('building2', $buildings[1]->getId());
+        $this->assertArrayNotHasKey('houses', $buildings[0]);
+        $this->assertArrayNotHasKey('houses', $buildings[1]);
 
         $database->createDocument('buildings', new Document([
             '$id' => 'building3',
@@ -1492,8 +1475,9 @@ public function testExceedMaxDepthOneToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1502,29 +1486,14 @@ public function testExceedMaxDepthOneToOne(): void
         $level3Collection = 'level3OneToOne';
         $level4Collection = 'level4OneToOne';
 
-        $database->createCollection($level1Collection);
-        $database->createCollection($level2Collection);
-        $database->createCollection($level3Collection);
-        $database->createCollection($level4Collection);
+        $database->createCollection(new Collection(id: $level1Collection));
+        $database->createCollection(new Collection(id: $level2Collection));
+        $database->createCollection(new Collection(id: $level3Collection));
+        $database->createCollection(new Collection(id: $level4Collection));
 
-        $database->createRelationship(
-            collection: $level1Collection,
-            relatedCollection: $level2Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level2Collection,
-            relatedCollection: $level3Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level3Collection,
-            relatedCollection: $level4Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $level1Collection, relatedCollection: $level2Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToOne(collection: $level2Collection, relatedCollection: $level3Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToOne(collection: $level3Collection, relatedCollection: $level4Collection, twoWay: true));
 
         // Exceed create depth
         $level1 = $database->createDocument($level1Collection, new Document([
@@ -1543,11 +1512,13 @@ public function testExceedMaxDepthOneToOne(): void
                 ],
             ],
         ]));
+        $level2 = $level1->getDocument($level2Collection);
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level2->getId());
+        $this->assertArrayHasKey($level3Collection, $level2);
+        $level3Related = $level2->getDocument($level3Collection);
+        $this->assertEquals('level3', $level3Related->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level3Related);
 
         // Confirm the 4th level document does not exist
         $level3 = $database->getDocument($level3Collection, 'level3');
@@ -1558,15 +1529,17 @@ public function testExceedMaxDepthOneToOne(): void
             '$id' => 'level4',
         ]));
         $level3 = $database->updateDocument($level3Collection, $level3->getId(), $level3);
-        $this->assertEquals('level4', $level3[$level4Collection]->getId());
+        $this->assertEquals('level4', $level3->getDocument($level4Collection)->getId());
 
         // Exceed fetch depth
         $level1 = $database->getDocument($level1Collection, 'level1');
+        $level2 = $level1->getDocument($level2Collection);
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level2->getId());
+        $this->assertArrayHasKey($level3Collection, $level2);
+        $level3Related = $level2->getDocument($level3Collection);
+        $this->assertEquals('level3', $level3Related->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level3Related);
     }
 
     public function testExceedMaxDepthOneToOneNull(): void
@@ -1574,8 +1547,9 @@ public function testExceedMaxDepthOneToOneNull(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1584,29 +1558,14 @@ public function testExceedMaxDepthOneToOneNull(): void
         $level3Collection = 'level3OneToOneNull';
         $level4Collection = 'level4OneToOneNull';
 
-        $database->createCollection($level1Collection);
-        $database->createCollection($level2Collection);
-        $database->createCollection($level3Collection);
-        $database->createCollection($level4Collection);
+        $database->createCollection(new Collection(id: $level1Collection));
+        $database->createCollection(new Collection(id: $level2Collection));
+        $database->createCollection(new Collection(id: $level3Collection));
+        $database->createCollection(new Collection(id: $level4Collection));
 
-        $database->createRelationship(
-            collection: $level1Collection,
-            relatedCollection: $level2Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level2Collection,
-            relatedCollection: $level3Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: $level3Collection,
-            relatedCollection: $level4Collection,
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $level1Collection, relatedCollection: $level2Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToOne(collection: $level2Collection, relatedCollection: $level3Collection, twoWay: true));
+        $database->createRelationship(Relationship::oneToOne(collection: $level3Collection, relatedCollection: $level4Collection, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1624,11 +1583,13 @@ public function testExceedMaxDepthOneToOneNull(): void
                 ],
             ],
         ]));
+        $level2 = $level1->getDocument($level2Collection);
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level2->getId());
+        $this->assertArrayHasKey($level3Collection, $level2);
+        $level3Related = $level2->getDocument($level3Collection);
+        $this->assertEquals('level3', $level3Related->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level3Related);
 
         // Confirm the 4th level document does not exist
         $level3 = $database->getDocument($level3Collection, 'level3');
@@ -1639,17 +1600,19 @@ public function testExceedMaxDepthOneToOneNull(): void
             '$id' => 'level4',
         ]));
         $level3 = $database->updateDocument($level3Collection, $level3->getId(), $level3);
-        $this->assertEquals('level4', $level3[$level4Collection]->getId());
+        $this->assertEquals('level4', $level3->getDocument($level4Collection)->getId());
         $level3 = $database->getDocument($level3Collection, 'level3');
-        $this->assertEquals('level4', $level3[$level4Collection]->getId());
+        $this->assertEquals('level4', $level3->getDocument($level4Collection)->getId());
 
         // Exceed fetch depth
         $level1 = $database->getDocument($level1Collection, 'level1');
+        $level2 = $level1->getDocument($level2Collection);
         $this->assertArrayHasKey($level2Collection, $level1);
-        $this->assertEquals('level2', $level1[$level2Collection]->getId());
-        $this->assertArrayHasKey($level3Collection, $level1[$level2Collection]);
-        $this->assertEquals('level3', $level1[$level2Collection][$level3Collection]->getId());
-        $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][$level3Collection]);
+        $this->assertEquals('level2', $level2->getId());
+        $this->assertArrayHasKey($level3Collection, $level2);
+        $level3Related = $level2->getDocument($level3Collection);
+        $this->assertEquals('level3', $level3Related->getId());
+        $this->assertArrayNotHasKey($level4Collection, $level3Related);
     }
 
     public function testOneToOneRelationshipKeyWithSymbols(): void
@@ -1657,42 +1620,38 @@ public function testOneToOneRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('$symbols_coll.ection1');
-        $database->createCollection('$symbols_coll.ection2');
+        $database->createCollection(new Collection(id: '$symbols_coll.ection1'));
+        $database->createCollection(new Collection(id: '$symbols_coll.ection2'));
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection1',
-            relatedCollection: '$symbols_coll.ection2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: '$symbols_coll.ection1', relatedCollection: '$symbols_coll.ection2', twoWay: true));
 
         $doc1 = $database->createDocument('$symbols_coll.ection2', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
         $doc2 = $database->createDocument('$symbols_coll.ection1', new Document([
             '$id' => ID::unique(),
-            '$symbols_coll.ection2' => $doc1->getId(),
+            'symbols_collection2' => $doc1->getId(),
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
-            ]
+                Permission::update(Role::any()),
+            ],
         ]));
 
         $doc1 = $database->getDocument('$symbols_coll.ection2', $doc1->getId());
         $doc2 = $database->getDocument('$symbols_coll.ection1', $doc2->getId());
 
-        $this->assertEquals($doc2->getId(), $doc1->getAttribute('$symbols_coll.ection1')->getId());
-        $this->assertEquals($doc1->getId(), $doc2->getAttribute('$symbols_coll.ection2')->getId());
+        $this->assertEquals($doc2->getId(), $doc1->getDocument('symbols_collection1')->getId());
+        $this->assertEquals($doc1->getId(), $doc2->getDocument('symbols_collection2')->getId());
     }
 
     public function testRecreateOneToOneOneWayRelationshipFromChild(): void
@@ -1700,65 +1659,42 @@ public function testRecreateOneToOneOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $result = $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneTwoWayRelationshipFromParent(): void
@@ -1766,67 +1702,42 @@ public function testRecreateOneToOneTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneTwoWayRelationshipFromChild(): void
@@ -1834,67 +1745,42 @@ public function testRecreateOneToOneTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $result = $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneOneWayRelationshipFromParent(): void
@@ -1902,65 +1788,42 @@ public function testRecreateOneToOneOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $database->createCollection('one', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+
+        $one = 'one_' . uniqid();
+        $two = 'two_' . uniqid();
+
+        $database->createCollection(new Collection(id: $one, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
-        $database->createCollection('two', [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'format' => '',
-                'size' => 100,
-                'signed' => true,
-                'required' => false,
-                'default' => null,
-                'array' => false,
-                'filters' => [],
-            ]),
-        ], [], [
+            Permission::delete(Role::any()),
+        ]));
+        $database->createCollection(new Collection(id: $two, attributes: [
+            Attribute::string(key: 'name', size: 100, format: ''),
+        ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
-        ]);
+            Permission::delete(Role::any()),
+        ]));
 
-        $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $result = $database->createRelationship(Relationship::oneToOne(collection: $one, relatedCollection: $two));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsOneToOneRelationship(): void
@@ -1968,25 +1831,21 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $this->getDatabase()->createCollection('bulk_delete_person_o2o');
-        $this->getDatabase()->createCollection('bulk_delete_library_o2o');
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_person_o2o'));
+        $this->getDatabase()->createCollection(new Collection(id: 'bulk_delete_library_o2o'));
 
-        $this->getDatabase()->createAttribute('bulk_delete_person_o2o', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', 'name', Database::VAR_STRING, 255, true);
-        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', 'area', Database::VAR_STRING, 255, true);
+        $this->getDatabase()->createAttribute('bulk_delete_person_o2o', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', Attribute::string(key: 'name', required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', Attribute::string(key: 'area', required: true));
 
         // Restrict
-        $this->getDatabase()->createRelationship(
-            collection: 'bulk_delete_person_o2o',
-            relatedCollection: 'bulk_delete_library_o2o',
-            type: Database::RELATION_ONE_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $this->getDatabase()->createRelationship(Relationship::oneToOne(collection: 'bulk_delete_person_o2o', relatedCollection: 'bulk_delete_library_o2o'));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2o', new Document([
             '$id' => 'person1',
@@ -2009,8 +1868,8 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
-        $library = $person1->getAttribute('bulk_delete_library_o2o');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('bulk_delete_library_o2o');
+        $this->assertEquals('library1', $library->getId());
         $this->assertArrayNotHasKey('bulk_delete_person_o2o', $library);
 
         // Delete person
@@ -2041,7 +1900,7 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         $this->getDatabase()->updateRelationship(
             collection: 'bulk_delete_person_o2o',
             id: 'bulk_delete_library_o2o',
-            onDelete: Database::RELATION_MUTATE_SET_NULL
+            onDelete: ForeignKeyAction::SetNull
         );
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2o', new Document([
@@ -2065,8 +1924,8 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
-        $library = $person1->getAttribute('bulk_delete_library_o2o');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('bulk_delete_library_o2o');
+        $this->assertEquals('library1', $library->getId());
         $this->assertArrayNotHasKey('bulk_delete_person_o2o', $library);
 
         $person = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
@@ -2089,7 +1948,7 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         $this->getDatabase()->updateRelationship(
             collection: 'bulk_delete_person_o2o',
             id: 'bulk_delete_library_o2o',
-            onDelete: Database::RELATION_MUTATE_CASCADE
+            onDelete: ForeignKeyAction::Cascade
         );
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2o', new Document([
@@ -2113,8 +1972,8 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
-        $library = $person1->getAttribute('bulk_delete_library_o2o');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('bulk_delete_library_o2o');
+        $this->assertEquals('library1', $library->getId());
         $this->assertArrayNotHasKey('bulk_delete_person_o2o', $library);
 
         $person = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
@@ -2153,8 +2012,8 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_o2o', 'person1');
-        $library = $person1->getAttribute('bulk_delete_library_o2o');
-        $this->assertEquals('library1', $library['$id']);
+        $library = $person1->getDocument('bulk_delete_library_o2o');
+        $this->assertEquals('library1', $library->getId());
         $this->assertArrayNotHasKey('bulk_delete_person_o2o', $library);
 
         $this->getDatabase()->deleteDocuments('bulk_delete_person_o2o');
@@ -2167,114 +2026,111 @@ public function testDeleteTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('drivers');
-        $database->createCollection('licenses');
+        $database->createCollection(new Collection(id: 'drivers'));
+        $database->createCollection(new Collection(id: 'licenses'));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'drivers',
             relatedCollection: 'licenses',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'license',
+            key: 'license',
             twoWayKey: 'driver'
-        );
+        ));
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(1, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(1, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(1, \count($drivers->attributes));
+        $this->assertEquals(1, \count($drivers->indexes));
+        $this->assertEquals(1, \count($licenses->attributes));
+        $this->assertEquals(1, \count($licenses->indexes));
 
         $database->deleteRelationship('licenses', 'driver');
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(0, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(0, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(0, \count($licenses->attributes));
+        $this->assertEquals(0, \count($licenses->indexes));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToMany(
             collection: 'drivers',
             relatedCollection: 'licenses',
-            type: Database::RELATION_ONE_TO_MANY,
             twoWay: true,
-            id: 'licenses',
+            key: 'licenses',
             twoWayKey: 'driver'
-        );
+        ));
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(1, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(1, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(1, \count($licenses->attributes));
+        $this->assertEquals(1, \count($licenses->indexes));
 
         $database->deleteRelationship('licenses', 'driver');
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(0, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(0, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(0, \count($licenses->attributes));
+        $this->assertEquals(0, \count($licenses->indexes));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToOne(
             collection: 'licenses',
             relatedCollection: 'drivers',
-            type: Database::RELATION_MANY_TO_ONE,
             twoWay: true,
-            id: 'driver',
+            key: 'driver',
             twoWayKey: 'licenses'
-        );
+        ));
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(1, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(1, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(1, \count($licenses->attributes));
+        $this->assertEquals(1, \count($licenses->indexes));
 
         $database->deleteRelationship('drivers', 'licenses');
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
 
-        $this->assertEquals(0, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(0, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(0, \count($licenses->attributes));
+        $this->assertEquals(0, \count($licenses->indexes));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::manyToMany(
             collection: 'licenses',
             relatedCollection: 'drivers',
-            type: Database::RELATION_MANY_TO_MANY,
             twoWay: true,
-            id: 'drivers',
+            key: 'drivers',
             twoWayKey: 'licenses'
-        );
+        ));
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
-        $junction = $database->getCollection('_' . $licenses->getSequence() . '_' . $drivers->getSequence());
+        $junction = $database->getCollection('_'.$licenses->getSequence().'_'.$drivers->getSequence());
 
-        $this->assertEquals(1, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(1, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('indexes')));
-        $this->assertEquals(2, \count($junction->getAttribute('attributes')));
-        $this->assertEquals(2, \count($junction->getAttribute('indexes')));
+        $this->assertEquals(1, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(1, \count($licenses->attributes));
+        $this->assertEquals(0, \count($licenses->indexes));
+        $this->assertEquals(2, \count($junction->attributes));
+        $this->assertEquals(2, \count($junction->indexes));
 
         $database->deleteRelationship('drivers', 'licenses');
 
@@ -2282,42 +2138,39 @@ public function testDeleteTwoWayRelationshipFromChild(): void
         $licenses = $database->getCollection('licenses');
         $junction = $database->getCollection('_licenses_drivers');
 
-        $this->assertEquals(0, \count($drivers->getAttribute('attributes')));
-        $this->assertEquals(0, \count($drivers->getAttribute('indexes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('attributes')));
-        $this->assertEquals(0, \count($licenses->getAttribute('indexes')));
+        $this->assertEquals(0, \count($drivers->attributes));
+        $this->assertEquals(0, \count($drivers->indexes));
+        $this->assertEquals(0, \count($licenses->attributes));
+        $this->assertEquals(0, \count($licenses->indexes));
 
         $this->assertEquals(true, $junction->isEmpty());
     }
+
     public function testUpdateParentAndChild_OneToOne(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
         if (
-            !$database->getAdapter()->getSupportForRelationships() ||
-            !$database->getAdapter()->getSupportForBatchOperations()
+            ! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_combined_o2o';
         $childCollection = 'child_combined_o2o';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
 
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'parentNumber', Database::VAR_INTEGER, 0, false);
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::integer(key: 'parentNumber'));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $parentCollection, relatedCollection: $childCollection, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2377,25 +2230,21 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToOne
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parentCollection = 'parent_relationship_error_one_to_one';
         $childCollection = 'child_relationship_error_one_to_one';
 
-        $database->createCollection($parentCollection);
-        $database->createCollection($childCollection);
-        $database->createAttribute($parentCollection, 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute($childCollection, 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: $parentCollection));
+        $database->createCollection(new Collection(id: $childCollection));
+        $database->createAttribute($parentCollection, Attribute::string(key: 'name', required: true));
+        $database->createAttribute($childCollection, Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: $parentCollection, relatedCollection: $childCollection));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2413,7 +2262,7 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToOne
                     Permission::delete(Role::any()),
                 ],
                 'name' => 'Child 1',
-            ]
+            ],
         ]));
 
         try {
@@ -2435,27 +2284,27 @@ public function testPartialUpdateOneToOneWithRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Setup collections with relationships
-        $database->createCollection('cities_partial');
-        $database->createCollection('mayors_partial');
+        $database->createCollection(new Collection(id: 'cities_partial'));
+        $database->createCollection(new Collection(id: 'mayors_partial'));
 
-        $database->createAttribute('cities_partial', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('cities_partial', 'population', Database::VAR_INTEGER, 0, false);
-        $database->createAttribute('mayors_partial', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('cities_partial', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('cities_partial', Attribute::integer(key: 'population'));
+        $database->createAttribute('mayors_partial', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'cities_partial',
             relatedCollection: 'mayors_partial',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'mayor',
+            key: 'mayor',
             twoWayKey: 'city'
-        );
+        ));
 
         // Create a city with a mayor
         $database->createDocument('cities_partial', new Document([
@@ -2480,11 +2329,11 @@ public function testPartialUpdateOneToOneWithRelationships(): void
         $city = $database->getDocument('cities_partial', 'city1');
         $this->assertEquals('Test City', $city->getAttribute('name'));
         $this->assertEquals(100000, $city->getAttribute('population'));
-        $this->assertEquals('mayor1', $city->getAttribute('mayor')->getId());
+        $this->assertEquals('mayor1', $city->getDocument('mayor')->getId());
 
         $mayor = $database->getDocument('mayors_partial', 'mayor1');
         $this->assertEquals('Test Mayor', $mayor->getAttribute('name'));
-        $this->assertEquals('city1', $mayor->getAttribute('city')->getId());
+        $this->assertEquals('city1', $mayor->getDocument('city')->getId());
 
         // Perform a partial update - ONLY update the city name, NOT the mayor relationship
         $database->updateDocument('cities_partial', 'city1', new Document([
@@ -2504,14 +2353,13 @@ public function testPartialUpdateOneToOneWithRelationships(): void
         $this->assertEquals(100000, $cityAfterUpdate->getAttribute('population'), 'Population should be preserved');
 
         // This is the critical test - the mayor relationship should still exist
-        $mayorAfterUpdate = $cityAfterUpdate->getAttribute('mayor');
-        $this->assertNotNull($mayorAfterUpdate, 'Mayor relationship should be preserved after partial update');
+        $mayorAfterUpdate = $cityAfterUpdate->getDocument('mayor');
         $this->assertEquals('mayor1', $mayorAfterUpdate->getId(), 'Mayor ID should still be mayor1');
 
         // Verify the bidirectional relationship is still intact
         $mayor = $database->getDocument('mayors_partial', 'mayor1');
-        $this->assertEquals('city1', $mayor->getAttribute('city')->getId(), 'Reverse relationship should be preserved');
-        $this->assertEquals('Updated City Name', $mayor->getAttribute('city')->getAttribute('name'), 'Reverse relationship should reflect updated city name');
+        $this->assertEquals('city1', $mayor->getDocument('city')->getId(), 'Reverse relationship should be preserved');
+        $this->assertEquals('Updated City Name', $mayor->getDocument('city')->getAttribute('name'), 'Reverse relationship should reflect updated city name');
 
         $database->deleteCollection('cities_partial');
         $database->deleteCollection('mayors_partial');
@@ -2522,26 +2370,26 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Recreate the exact scenario from testNestedOneToMany_OneToOneRelationship
-        $database->createCollection('cities_strict');
-        $database->createCollection('mayors_strict');
+        $database->createCollection(new Collection(id: 'cities_strict'));
+        $database->createCollection(new Collection(id: 'mayors_strict'));
 
-        $database->createAttribute('cities_strict', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('mayors_strict', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('cities_strict', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('mayors_strict', Attribute::string(key: 'name', required: true));
 
-        $database->createRelationship(
+        $database->createRelationship(Relationship::oneToOne(
             collection: 'cities_strict',
             relatedCollection: 'mayors_strict',
-            type: Database::RELATION_ONE_TO_ONE,
             twoWay: true,
-            id: 'mayor',
+            key: 'mayor',
             twoWayKey: 'city'
-        );
+        ));
 
         // Create city with mayor
         $database->createDocument('cities_strict', new Document([
@@ -2564,7 +2412,7 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         // Get the current state to verify
         $cityBefore = $database->getDocument('cities_strict', 'city1');
         $this->assertEquals('City 1', $cityBefore->getAttribute('name'));
-        $this->assertEquals('mayor1', $cityBefore->getAttribute('mayor')->getId());
+        $this->assertEquals('mayor1', $cityBefore->getDocument('mayor')->getId());
 
         // Now do what the comment says we "don't support" - update WITHOUT including mayor field
         // Creating a fresh Document object with only the fields we want to update
@@ -2586,91 +2434,13 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         $this->assertEquals('City 1 updated', $cityAfter->getAttribute('name'));
 
         // The relationship should still exist
-        $mayorAttr = $cityAfter->getAttribute('mayor');
-        $this->assertNotNull($mayorAttr, 'Mayor should still be set after partial update without mayor field');
-        $this->assertEquals('mayor1', $mayorAttr->getId());
+        $this->assertEquals('mayor1', $cityAfter->getDocument('mayor')->getId());
 
         // Also verify the reverse relationship
         $mayor = $database->getDocument('mayors_strict', 'mayor1');
-        $this->assertEquals('city1', $mayor->getAttribute('city')->getId());
+        $this->assertEquals('city1', $mayor->getDocument('city')->getId());
 
         $database->deleteCollection('cities_strict');
         $database->deleteCollection('mayors_strict');
     }
-
-    public function testOneToOneRelationshipRejectsArrayOperators(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if (!$database->getAdapter()->getSupportForOperators()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Cleanup any leftover collections from previous runs
-        try {
-            $database->deleteCollection('user_o2o');
-        } catch (\Throwable $e) {
-        }
-        try {
-            $database->deleteCollection('profile_o2o');
-        } catch (\Throwable $e) {
-        }
-
-        $database->createCollection('user_o2o');
-        $database->createCollection('profile_o2o');
-
-        $database->createAttribute('user_o2o', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profile_o2o', 'bio', Database::VAR_STRING, 255, true);
-
-        $database->createRelationship(
-            collection: 'user_o2o',
-            relatedCollection: 'profile_o2o',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'profile',
-            twoWayKey: 'user'
-        );
-
-        // Create a profile
-        $database->createDocument('profile_o2o', new Document([
-            '$id' => 'profile1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'bio' => 'Test bio',
-        ]));
-
-        // Create user with profile
-        $database->createDocument('user_o2o', new Document([
-            '$id' => 'user1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::update(Role::any()),
-            ],
-            'name' => 'User 1',
-            'profile' => 'profile1',
-        ]));
-
-        // Array operators should fail on one-to-one relationships
-        try {
-            $database->updateDocument('user_o2o', 'user1', new Document([
-                'profile' => \Utopia\Database\Operator::arrayAppend(['profile2']),
-            ]));
-            $this->fail('Expected exception for array operator on one-to-one relationship');
-        } catch (\Utopia\Database\Exception\Structure $e) {
-            $this->assertStringContainsString('single-value relationship', $e->getMessage());
-        }
-
-        // Cleanup
-        $database->deleteCollection('user_o2o');
-        $database->deleteCollection('profile_o2o');
-    }
 }
diff --git a/tests/e2e/Adapter/Scopes/SchemalessTests.php b/tests/e2e/Adapter/Scopes/SchemalessTests.php
index 9f8d150bf6..e493ee9cc1 100644
--- a/tests/e2e/Adapter/Scopes/SchemalessTests.php
+++ b/tests/e2e/Adapter/Scopes/SchemalessTests.php
@@ -3,35 +3,54 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
-use Throwable;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
-use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
-use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Exception\Type as TypeException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 
 trait SchemalessTests
 {
+    private function asString(mixed $value): string
+    {
+        $this->assertIsString($value);
+
+        return $value;
+    }
+
+    private function asDocument(mixed $value): Document
+    {
+        $this->assertInstanceOf(Document::class, $value);
+
+        return $value;
+    }
+
     public function testSchemalessDocumentOperation(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $colName = uniqid('schemaless');
-        $database->createCollection($colName);
-        $database->createAttribute($colName, 'key', Database::VAR_STRING, 50, true);
-        $database->createAttribute($colName, 'value', Database::VAR_STRING, 50, false, 'value');
+        $database->createCollection(new Collection(id: $colName));
+        $database->createAttribute($colName, Attribute::string(key: 'key', size: 50, required: true));
+        $database->createAttribute($colName, Attribute::string(key: 'value', size: 50, default: 'value'));
 
         $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())];
 
@@ -115,57 +134,19 @@ public function testSchemalessDocumentOperation(): void
         $database->deleteCollection($colName);
     }
 
-    public function testSchemalessDocumentInvalidInteralAttributeValidation(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        // test to ensure internal attributes are checked during creating schemaless document
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $colName = uniqid('schemaless');
-        $database->createCollection($colName);
-        try {
-            $docs = [
-                new Document(['$id' => true, 'freeA' => 'doc1']),
-                new Document(['$id' => true, 'freeB' => 'test']),
-                new Document(['$id' => true]),
-            ];
-            $database->createDocuments($colName, $docs);
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-
-        try {
-            $docs = [
-                new Document(['$createdAt' => true, 'freeA' => 'doc1']),
-                new Document(['$updatedAt' => true, 'freeB' => 'test']),
-                new Document(['$permissions' => 12]),
-            ];
-            $database->createDocuments($colName, $docs);
-        } catch (\Throwable $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
-        }
-
-        $database->deleteCollection($colName);
-
-    }
-
     public function testSchemalessSelectionOnUnknownAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $colName = uniqid('schemaless');
-        $database->createCollection($colName);
+        $database->createCollection(new Collection(id: $colName));
         $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())];
         $docs = [
             new Document(['$id' => 'doc1', '$permissions' => $permissions, 'freeA' => 'doc1']),
@@ -180,7 +161,7 @@ public function testSchemalessSelectionOnUnknownAttributes(): void
         $docC = $database->getDocument($colName, 'doc1', [Query::select(['freeC'])]);
         $this->assertNull($docC->getAttribute('freeC'));
 
-        $docs = $database->find($colName, [Query::equal('$id', ['doc1','doc2']),Query::select(['freeC'])]);
+        $docs = $database->find($colName, [Query::equal('$id', ['doc1', 'doc2']), Query::select(['freeC'])]);
         foreach ($docs as $doc) {
             $this->assertNull($doc->getAttribute('freeC'));
             // since not selected
@@ -190,13 +171,13 @@ public function testSchemalessSelectionOnUnknownAttributes(): void
 
         $docA = $database->find($colName, [
             Query::equal('$id', ['doc1']),
-            Query::select(['freeA'])
+            Query::select(['freeA']),
         ]);
         $this->assertEquals('doc1', $docA[0]->getAttribute('freeA'));
 
         $docC = $database->find($colName, [
             Query::equal('$id', ['doc1']),
-            Query::select(['freeC'])
+            Query::select(['freeC']),
         ]);
         $this->assertArrayNotHasKey('freeC', $docC[0]->getAttributes());
     }
@@ -206,27 +187,29 @@ public function testSchemalessIncrement(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_increment");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_increment');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [
             new Document(['$id' => 'doc1', '$permissions' => $permissions, 'counter' => 10, 'score' => 5.5]),
             new Document(['$id' => 'doc2', '$permissions' => $permissions, 'counter' => 20, 'points' => 100]),
             new Document(['$id' => 'doc3', '$permissions' => $permissions, 'value' => 0]),
+            new Document(['$id' => 'doc4', '$permissions' => $permissions, 'nullable' => null]),
         ];
-        $this->assertEquals(3, $database->createDocuments($colName, $docs));
+        $this->assertEquals(4, $database->createDocuments($colName, $docs));
 
         $doc1 = $database->increaseDocumentAttribute($colName, 'doc1', 'counter', 5);
         $this->assertEquals(15, $doc1->getAttribute('counter'));
@@ -242,6 +225,13 @@ public function testSchemalessIncrement(): void
         $this->assertEquals(1, $doc3->getAttribute('newCounter'));
         $this->assertEquals(0, $doc3->getAttribute('value'));
 
+        try {
+            $database->increaseDocumentAttribute($colName, 'doc4', 'nullable', 1);
+            $this->fail('An explicitly null attribute must not use the missing-attribute numeric default.');
+        } catch (TypeException) {
+            $this->addToAssertionCount(1);
+        }
+
         try {
             $database->increaseDocumentAttribute($colName, 'doc1', 'counter', 10, 20);
             $this->assertEquals(20, $database->getDocument($colName, 'doc1')->getAttribute('counter'));
@@ -250,7 +240,7 @@ public function testSchemalessIncrement(): void
         }
 
         $allDocs = $database->find($colName);
-        $this->assertCount(3, $allDocs);
+        $this->assertCount(4, $allDocs);
 
         $database->deleteCollection($colName);
     }
@@ -260,19 +250,20 @@ public function testSchemalessDecrement(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_decrement");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_decrement');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [
@@ -314,19 +305,20 @@ public function testSchemalessUpdateDocumentWithQuery(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_update");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_update');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [
@@ -340,7 +332,7 @@ public function testSchemalessUpdateDocumentWithQuery(): void
         $updatedDoc = $database->updateDocument($colName, 'doc1', new Document([
             'status' => 'updated',
             'lastModified' => '2023-01-01',
-            'newAttribute' => 'added'
+            'newAttribute' => 'added',
         ]));
 
         $this->assertEquals('updated', $updatedDoc->getAttribute('status'));
@@ -356,7 +348,7 @@ public function testSchemalessUpdateDocumentWithQuery(): void
         $updatedDoc2 = $database->updateDocument($colName, 'doc2', new Document([
             'customField1' => 'value1',
             'customField2' => 42,
-            'customField3' => ['array', 'of', 'values']
+            'customField3' => ['array', 'of', 'values'],
         ]));
 
         $this->assertEquals('value1', $updatedDoc2->getAttribute('customField1'));
@@ -372,19 +364,20 @@ public function testSchemalessDeleteDocumentWithQuery(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_delete");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_delete');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [
@@ -415,24 +408,26 @@ public function testSchemalessUpdateDocumentsWithQuery(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_bulk_update");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_bulk_update');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [];
@@ -443,7 +438,7 @@ public function testSchemalessUpdateDocumentsWithQuery(): void
                 'type' => $i <= 5 ? 'typeA' : 'typeB',
                 'status' => 'pending',
                 'score' => $i * 10,
-                'customField' => "value{$i}"
+                'customField' => "value{$i}",
             ]);
         }
         $this->assertEquals(10, $database->createDocuments($colName, $docs));
@@ -451,7 +446,7 @@ public function testSchemalessUpdateDocumentsWithQuery(): void
         $updatedCount = $database->updateDocuments($colName, new Document([
             'status' => 'processed',
             'processedAt' => '2023-01-01',
-            'newBulkField' => 'bulk_value'
+            'newBulkField' => 'bulk_value',
         ]), [Query::equal('type', ['typeA'])]);
 
         $this->assertEquals(5, $updatedCount);
@@ -479,7 +474,7 @@ public function testSchemalessUpdateDocumentsWithQuery(): void
         }
 
         $highScoreCount = $database->updateDocuments($colName, new Document([
-            'tier' => 'premium'
+            'tier' => 'premium',
         ]), [Query::greaterThan('score', 70)]);
 
         $this->assertEquals(3, $highScoreCount); // docs 8, 9, 10
@@ -489,7 +484,7 @@ public function testSchemalessUpdateDocumentsWithQuery(): void
 
         $allUpdateCount = $database->updateDocuments($colName, new Document([
             'globalFlag' => true,
-            'lastUpdate' => '2023-12-31'
+            'lastUpdate' => '2023-12-31',
         ]));
 
         $this->assertEquals(10, $allUpdateCount);
@@ -510,24 +505,26 @@ public function testSchemalessDeleteDocumentsWithQuery(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_bulk_delete");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_bulk_delete');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [];
@@ -539,7 +536,7 @@ public function testSchemalessDeleteDocumentsWithQuery(): void
                 'priority' => $i % 3, // 0, 1, or 2
                 'score' => $i * 5,
                 'tags' => ["tag{$i}", 'common'],
-                'metadata' => ['created' => "2023-01-{$i}"]
+                'metadata' => ['created' => "2023-01-{$i}"],
             ]);
         }
         $this->assertEquals(15, $database->createDocuments($colName, $docs));
@@ -566,7 +563,7 @@ public function testSchemalessDeleteDocumentsWithQuery(): void
 
         $multiConditionDeleted = $database->deleteDocuments($colName, [
             Query::equal('category', ['archive']),
-            Query::equal('priority', [1])
+            Query::equal('priority', [1]),
         ]);
         $this->assertEquals(2, $multiConditionDeleted); // docs 7 and 10
 
@@ -592,24 +589,26 @@ public function testSchemalessOperationsWithCallback(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $colName = uniqid("schemaless_callbacks");
-        $database->createCollection($colName);
+        $colName = uniqid('schemaless_callbacks');
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [];
@@ -619,7 +618,7 @@ public function testSchemalessOperationsWithCallback(): void
                 '$permissions' => $permissions,
                 'group' => $i <= 4 ? 'A' : 'B',
                 'value' => $i * 10,
-                'customData' => "data{$i}"
+                'customData' => "data{$i}",
             ]);
         }
         $this->assertEquals(8, $database->createDocuments($colName, $docs));
@@ -644,6 +643,7 @@ public function testSchemalessOperationsWithCallback(): void
         $processedDocs = $database->find($colName, [Query::equal('processed', [true])]);
         $this->assertCount(4, $processedDocs);
 
+        /** @var list<array{id: string, value: mixed, customData: mixed}> $deleteResults */
         $deleteResults = [];
         $deleteCount = $database->deleteDocuments(
             $colName,
@@ -652,7 +652,7 @@ public function testSchemalessOperationsWithCallback(): void
                 $deleteResults[] = [
                     'id' => $doc->getId(),
                     'value' => $doc->getAttribute('value'),
-                    'customData' => $doc->getAttribute('customData')
+                    'customData' => $doc->getAttribute('customData'),
                 ];
             }
         );
@@ -662,7 +662,7 @@ public function testSchemalessOperationsWithCallback(): void
 
         foreach ($deleteResults as $result) {
             $this->assertGreaterThan(50, $result['value']);
-            $this->assertStringStartsWith('data', $result['customData']);
+            $this->assertStringStartsWith('data', $this->asString($result['customData']));
         }
 
         $remainingDocs = $database->find($colName);
@@ -680,14 +680,15 @@ public function testSchemalessIndexCreateListDelete(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Schemaless adapter still supports defining attributes/indexes metadata
         $col = uniqid('sl_idx');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $database->createDocument($col, new Document([
             '$id' => 'a',
@@ -702,11 +703,11 @@ public function testSchemalessIndexCreateListDelete(): void
             'rank' => 2,
         ]));
 
-        $this->assertTrue($database->createIndex($col, 'idx_title_unique', Database::INDEX_UNIQUE, ['title'], [128], [Database::ORDER_ASC]));
-        $this->assertTrue($database->createIndex($col, 'idx_rank_key', Database::INDEX_KEY, ['rank'], [0], [Database::ORDER_ASC]));
+        $this->assertTrue($database->createIndex($col, Index::unique(key: 'idx_title_unique', attributes: ['title'], lengths: [128], orders: [Order::Asc])));
+        $this->assertTrue($database->createIndex($col, Index::key(key: 'idx_rank_key', attributes: ['rank'], lengths: [0], orders: [Order::Asc])));
 
         $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(2, $indexes);
         $ids = array_map(fn ($i) => $i['$id'], $indexes);
         $this->assertContains('idx_rank_key', $ids);
@@ -714,89 +715,45 @@ public function testSchemalessIndexCreateListDelete(): void
 
         $this->assertTrue($database->deleteIndex($col, 'idx_rank_key'));
         $collection = $database->getCollection($col);
-        $this->assertCount(1, $collection->getAttribute('indexes'));
-        $this->assertEquals('idx_title_unique', $collection->getAttribute('indexes')[0]['$id']);
+        $this->assertCount(1, $collection->indexes);
+        $this->assertEquals('idx_title_unique', $collection->indexes[0]['$id']);
 
         $this->assertTrue($database->deleteIndex($col, 'idx_title_unique'));
         $database->deleteCollection($col);
     }
 
-    public function testSchemalessIndexDuplicatePrevention(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $col = uniqid('sl_idx_dup');
-        $database->createCollection($col);
-
-        $database->createDocument($col, new Document([
-            '$id' => 'a',
-            '$permissions' => [Permission::read(Role::any())],
-            'name' => 'x'
-        ]));
-
-        $this->assertTrue($database->createIndex($col, 'duplicate', Database::INDEX_KEY, ['name'], [0], [Database::ORDER_ASC]));
-
-        try {
-            $database->createIndex($col, 'duplicate', Database::INDEX_KEY, ['name'], [0], [Database::ORDER_ASC]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
-
-        $database->deleteCollection($col);
-    }
-
     public function testSchemalessObjectIndexes(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
         // Only run for schemaless adapters that support object attributes
-        if ($database->getAdapter()->getSupportForAttributes() || !$database->getAdapter()->getSupportForObject()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes) || ! $database->getAdapter()->supports(Capability::Objects)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_obj_idx');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         // Define object attributes in metadata
-        $database->createAttribute($col, 'meta', Database::VAR_OBJECT, 0, false);
-        $database->createAttribute($col, 'meta2', Database::VAR_OBJECT, 0, false);
+        $database->createAttribute($col, Attribute::object(key: 'meta'));
+        $database->createAttribute($col, Attribute::object(key: 'meta2'));
 
         // Create regular key index on first object attribute
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_meta_key',
-                Database::INDEX_KEY,
-                ['meta'],
-                [0],
-                [Database::ORDER_ASC]
-            )
+            $database->createIndex($col, Index::key(key: 'idx_meta_key', attributes: ['meta'], lengths: [0], orders: [Order::Asc]))
         );
 
         // Create unique index on second object attribute
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_meta_unique',
-                Database::INDEX_UNIQUE,
-                ['meta2'],
-                [0],
-                [Database::ORDER_ASC]
-            )
+            $database->createIndex($col, Index::unique(key: 'idx_meta_unique', attributes: ['meta2'], lengths: [0], orders: [Order::Asc]))
         );
 
         // Verify index metadata is stored on the collection
         $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(2, $indexes);
         $ids = array_map(fn ($i) => $i['$id'], $indexes);
         $this->assertContains('idx_meta_key', $ids);
@@ -813,21 +770,22 @@ public function testSchemalessPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_perms');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         // Create with permissive read only
         $doc = $database->createDocument($col, new Document([
             '$id' => 'd1',
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'field' => 'value'
+            'field' => 'value',
         ]));
 
         $this->assertFalse($doc->isEmpty());
@@ -858,7 +816,7 @@ public function testSchemalessPermissions(): void
                 '$permissions' => [
                     Permission::read(Role::any()),
                     Permission::update(Role::any()),
-                ]
+                ],
             ]));
         });
 
@@ -869,7 +827,7 @@ public function testSchemalessPermissions(): void
         $database->getAuthorization()->cleanRoles();
         try {
             $database->createDocument($col, new Document([
-                'field' => 'x'
+                'field' => 'x',
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -880,143 +838,34 @@ public function testSchemalessPermissions(): void
         $database->getAuthorization()->cleanRoles();
     }
 
-    public function testSchemalessInternalAttributes(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $col = uniqid('sl_internal_full');
-        $database->createCollection($col);
-
-        $database->getAuthorization()->addRole(Role::any()->toString());
-
-        $doc = $database->createDocument($col, new Document([
-            '$id' => 'i1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'name' => 'alpha',
-        ]));
-
-        $this->assertEquals('i1', $doc->getId());
-        $this->assertEquals($col, $doc->getCollection());
-        $this->assertNotEmpty($doc->getSequence());
-        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-        $perms = $doc->getPermissions();
-        $this->assertGreaterThanOrEqual(1, count($perms));
-        $this->assertContains(Permission::read(Role::any()), $perms);
-        $this->assertContains(Permission::update(Role::any()), $perms);
-        $this->assertContains(Permission::delete(Role::any()), $perms);
-
-        $selected = $database->getDocument($col, 'i1', [
-            Query::select(['name', '$id', '$sequence', '$collection', '$createdAt', '$updatedAt', '$permissions'])
-        ]);
-        $this->assertEquals('alpha', $selected->getAttribute('name'));
-        $this->assertArrayHasKey('$id', $selected);
-        $this->assertArrayHasKey('$sequence', $selected);
-        $this->assertArrayHasKey('$collection', $selected);
-        $this->assertArrayHasKey('$createdAt', $selected);
-        $this->assertArrayHasKey('$updatedAt', $selected);
-        $this->assertArrayHasKey('$permissions', $selected);
-
-        $found = $database->find($col, [
-            Query::equal('$id', ['i1']),
-            Query::select(['$id', '$sequence', '$collection', '$createdAt', '$updatedAt', '$permissions'])
-        ]);
-        $this->assertCount(1, $found);
-        $this->assertArrayHasKey('$id', $found[0]);
-        $this->assertArrayHasKey('$sequence', $found[0]);
-        $this->assertArrayHasKey('$collection', $found[0]);
-        $this->assertArrayHasKey('$createdAt', $found[0]);
-        $this->assertArrayHasKey('$updatedAt', $found[0]);
-        $this->assertArrayHasKey('$permissions', $found[0]);
-
-        $seq = $doc->getSequence();
-        $bySeq = $database->find($col, [Query::equal('$sequence', [$seq])]);
-        $this->assertCount(1, $bySeq);
-        $this->assertEquals('i1', $bySeq[0]->getId());
-
-        $createdAtBefore = $doc->getAttribute('$createdAt');
-        $updatedAtBefore = $doc->getAttribute('$updatedAt');
-        $updated = $database->updateDocument($col, 'i1', new Document(['name' => 'beta']));
-        $this->assertEquals('beta', $updated->getAttribute('name'));
-        $this->assertEquals($createdAtBefore, $updated->getAttribute('$createdAt'));
-        $this->assertNotEquals($updatedAtBefore, $updated->getAttribute('$updatedAt'));
-
-        $changed = $database->updateDocument($col, 'i1', new Document(['$id' => 'i1-new']));
-        $this->assertEquals('i1-new', $changed->getId());
-        $refetched = $database->getDocument($col, 'i1-new');
-        $this->assertEquals('i1-new', $refetched->getId());
-
-        try {
-            $database->updateDocument($col, 'i1-new', new Document(['$permissions' => 'invalid']));
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertTrue($e instanceof StructureException);
-        }
-
-        $database->setPreserveDates(true);
-        $customCreated = '2000-01-01T00:00:00.000+00:00';
-        $customUpdated = '2000-01-02T00:00:00.000+00:00';
-        $d2 = $database->createDocument($col, new Document([
-            '$id' => 'i2',
-            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
-            '$createdAt' => $customCreated,
-            '$updatedAt' => $customUpdated,
-            'v' => 1
-        ]));
-        $this->assertEquals($customCreated, $d2->getAttribute('$createdAt'));
-        $this->assertEquals($customUpdated, $d2->getAttribute('$updatedAt'));
-
-        $newUpdated = '2000-01-03T00:00:00.000+00:00';
-        $d2u = $database->updateDocument($col, 'i2', new Document([
-            'v' => 2,
-            '$updatedAt' => $newUpdated
-        ]));
-        $this->assertEquals($customCreated, $d2u->getAttribute('$createdAt'));
-        $this->assertEquals($newUpdated, $d2u->getAttribute('$updatedAt'));
-        $database->setPreserveDates(false);
-
-        $database->deleteCollection($col);
-        $database->getAuthorization()->cleanRoles();
-    }
-
     public function testSchemalessDates(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_dates');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Seed deterministic date strings
         $createdAt1 = '2000-01-01T10:00:00.000+00:00';
         $updatedAt1 = '2000-01-02T11:11:11.000+00:00';
-        $curDate1   = '2000-01-05T05:05:05.000+00:00';
+        $curDate1 = '2000-01-05T05:05:05.000+00:00';
 
         // createDocument with preserved dates
-        $doc1 = $database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt1, $updatedAt1, $curDate1) {
+        $doc1 = $this->asDocument($database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt1, $updatedAt1, $curDate1) {
             return $database->createDocument($col, new Document([
                 '$id' => 'd1',
                 '$permissions' => $permissions,
@@ -1025,13 +874,13 @@ public function testSchemalessDates(): void
                 'curDate' => $curDate1,
                 'counter' => 0,
             ]));
-        });
+        }));
 
         $this->assertEquals('d1', $doc1->getId());
         $this->assertTrue(is_string($doc1->getAttribute('curDate')));
         // MongoDB converts ISO 8601 to 'Y-m-d H:i:s.v' format, so compare by parsing
         $curDate1Value = $doc1->getAttribute('curDate');
-        $parsedCurDate1 = new \DateTime($curDate1Value);
+        $parsedCurDate1 = new \DateTime($this->asString($curDate1Value));
         $parsedExpectedCurDate1 = new \DateTime($curDate1);
         $this->assertEquals($parsedExpectedCurDate1->getTimestamp(), $parsedCurDate1->getTimestamp());
         $this->assertTrue(is_string($doc1->getAttribute('$createdAt')));
@@ -1039,8 +888,8 @@ public function testSchemalessDates(): void
         // Internal attributes should preserve format better, but verify by parsing for MongoDB
         $createdAt1Value = $doc1->getAttribute('$createdAt');
         $updatedAt1Value = $doc1->getAttribute('$updatedAt');
-        $parsedCreatedAt1 = new \DateTime($createdAt1Value);
-        $parsedUpdatedAt1 = new \DateTime($updatedAt1Value);
+        $parsedCreatedAt1 = new \DateTime($this->asString($createdAt1Value));
+        $parsedUpdatedAt1 = new \DateTime($this->asString($updatedAt1Value));
         $parsedExpectedCreatedAt1 = new \DateTime($createdAt1);
         $parsedExpectedUpdatedAt1 = new \DateTime($updatedAt1);
         $this->assertEquals($parsedExpectedCreatedAt1->getTimestamp(), $parsedCreatedAt1->getTimestamp());
@@ -1049,25 +898,25 @@ public function testSchemalessDates(): void
         $fetched1 = $database->getDocument($col, 'd1');
         $fetchedCurDate1 = $fetched1->getAttribute('curDate');
         $this->assertTrue(is_string($fetchedCurDate1));
-        $parsedFetchedCurDate1 = new \DateTime($fetchedCurDate1);
+        $parsedFetchedCurDate1 = new \DateTime($this->asString($fetchedCurDate1));
         $this->assertEquals($parsedExpectedCurDate1->getTimestamp(), $parsedFetchedCurDate1->getTimestamp());
         $this->assertTrue(is_string($fetched1->getAttribute('$createdAt')));
         $this->assertTrue(is_string($fetched1->getAttribute('$updatedAt')));
         $fetchedCreatedAt1 = $fetched1->getAttribute('$createdAt');
         $fetchedUpdatedAt1 = $fetched1->getAttribute('$updatedAt');
-        $parsedFetchedCreatedAt1 = new \DateTime($fetchedCreatedAt1);
-        $parsedFetchedUpdatedAt1 = new \DateTime($fetchedUpdatedAt1);
+        $parsedFetchedCreatedAt1 = new \DateTime($this->asString($fetchedCreatedAt1));
+        $parsedFetchedUpdatedAt1 = new \DateTime($this->asString($fetchedUpdatedAt1));
         $this->assertEquals($parsedExpectedCreatedAt1->getTimestamp(), $parsedFetchedCreatedAt1->getTimestamp());
         $this->assertEquals($parsedExpectedUpdatedAt1->getTimestamp(), $parsedFetchedUpdatedAt1->getTimestamp());
 
         // createDocuments with preserved dates
         $createdAt2 = '2001-02-03T04:05:06.000+00:00';
         $updatedAt2 = '2001-02-04T04:05:07.000+00:00';
-        $curDate2   = '2001-02-05T06:07:08.000+00:00';
+        $curDate2 = '2001-02-05T06:07:08.000+00:00';
 
         $createdAt3 = '2002-03-04T05:06:07.000+00:00';
         $updatedAt3 = '2002-03-05T05:06:08.000+00:00';
-        $curDate3   = '2002-03-06T07:08:09.000+00:00';
+        $curDate3 = '2002-03-06T07:08:09.000+00:00';
 
         $countCreated = $database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt2, $updatedAt2, $curDate2, $createdAt3, $updatedAt3, $curDate3) {
             return $database->createDocuments($col, [
@@ -1091,13 +940,13 @@ public function testSchemalessDates(): void
 
         $fetched2 = $database->getDocument($col, 'd2');
         $fetchedCurDate2 = $fetched2->getAttribute('curDate');
-        $parsedCurDate2 = new \DateTime($fetchedCurDate2);
+        $parsedCurDate2 = new \DateTime($this->asString($fetchedCurDate2));
         $parsedExpectedCurDate2 = new \DateTime($curDate2);
         $this->assertEquals($parsedExpectedCurDate2->getTimestamp(), $parsedCurDate2->getTimestamp());
         $fetchedCreatedAt2 = $fetched2->getAttribute('$createdAt');
         $fetchedUpdatedAt2 = $fetched2->getAttribute('$updatedAt');
-        $parsedCreatedAt2 = new \DateTime($fetchedCreatedAt2);
-        $parsedUpdatedAt2 = new \DateTime($fetchedUpdatedAt2);
+        $parsedCreatedAt2 = new \DateTime($this->asString($fetchedCreatedAt2));
+        $parsedUpdatedAt2 = new \DateTime($this->asString($fetchedUpdatedAt2));
         $parsedExpectedCreatedAt2 = new \DateTime($createdAt2);
         $parsedExpectedUpdatedAt2 = new \DateTime($updatedAt2);
         $this->assertEquals($parsedExpectedCreatedAt2->getTimestamp(), $parsedCreatedAt2->getTimestamp());
@@ -1105,31 +954,31 @@ public function testSchemalessDates(): void
 
         $fetched3 = $database->getDocument($col, 'd3');
         $fetchedCurDate3 = $fetched3->getAttribute('curDate');
-        $parsedCurDate3 = new \DateTime($fetchedCurDate3);
+        $parsedCurDate3 = new \DateTime($this->asString($fetchedCurDate3));
         $parsedExpectedCurDate3 = new \DateTime($curDate3);
         $this->assertEquals($parsedExpectedCurDate3->getTimestamp(), $parsedCurDate3->getTimestamp());
         $fetchedCreatedAt3 = $fetched3->getAttribute('$createdAt');
         $fetchedUpdatedAt3 = $fetched3->getAttribute('$updatedAt');
-        $parsedCreatedAt3 = new \DateTime($fetchedCreatedAt3);
-        $parsedUpdatedAt3 = new \DateTime($fetchedUpdatedAt3);
+        $parsedCreatedAt3 = new \DateTime($this->asString($fetchedCreatedAt3));
+        $parsedUpdatedAt3 = new \DateTime($this->asString($fetchedUpdatedAt3));
         $parsedExpectedCreatedAt3 = new \DateTime($createdAt3);
         $parsedExpectedUpdatedAt3 = new \DateTime($updatedAt3);
         $this->assertEquals($parsedExpectedCreatedAt3->getTimestamp(), $parsedCreatedAt3->getTimestamp());
         $this->assertEquals($parsedExpectedUpdatedAt3->getTimestamp(), $parsedUpdatedAt3->getTimestamp());
 
         // updateDocument with preserved $updatedAt and custom date field
-        $newCurDate1   = '2000-02-01T00:00:00.000+00:00';
+        $newCurDate1 = '2000-02-01T00:00:00.000+00:00';
         $newUpdatedAt1 = '2000-02-02T02:02:02.000+00:00';
-        $updated1 = $database->withPreserveDates(function () use ($database, $col, $newCurDate1, $newUpdatedAt1) {
+        $updated1 = $this->asDocument($database->withPreserveDates(function () use ($database, $col, $newCurDate1, $newUpdatedAt1) {
             return $database->updateDocument($col, 'd1', new Document([
                 'curDate' => $newCurDate1,
                 '$updatedAt' => $newUpdatedAt1,
             ]));
-        });
+        }));
         $updatedCurDate1 = $updated1->getAttribute('curDate');
         $updatedUpdatedAt1 = $updated1->getAttribute('$updatedAt');
-        $parsedUpdatedCurDate1 = new \DateTime($updatedCurDate1);
-        $parsedUpdatedUpdatedAt1 = new \DateTime($updatedUpdatedAt1);
+        $parsedUpdatedCurDate1 = new \DateTime($this->asString($updatedCurDate1));
+        $parsedUpdatedUpdatedAt1 = new \DateTime($this->asString($updatedUpdatedAt1));
         $parsedExpectedNewCurDate1 = new \DateTime($newCurDate1);
         $parsedExpectedNewUpdatedAt1 = new \DateTime($newUpdatedAt1);
         $this->assertEquals($parsedExpectedNewCurDate1->getTimestamp(), $parsedUpdatedCurDate1->getTimestamp());
@@ -1137,13 +986,13 @@ public function testSchemalessDates(): void
         $refetched1 = $database->getDocument($col, 'd1');
         $refetchedCurDate1 = $refetched1->getAttribute('curDate');
         $refetchedUpdatedAt1 = $refetched1->getAttribute('$updatedAt');
-        $parsedRefetchedCurDate1 = new \DateTime($refetchedCurDate1);
-        $parsedRefetchedUpdatedAt1 = new \DateTime($refetchedUpdatedAt1);
+        $parsedRefetchedCurDate1 = new \DateTime($this->asString($refetchedCurDate1));
+        $parsedRefetchedUpdatedAt1 = new \DateTime($this->asString($refetchedUpdatedAt1));
         $this->assertEquals($parsedExpectedNewCurDate1->getTimestamp(), $parsedRefetchedCurDate1->getTimestamp());
         $this->assertEquals($parsedExpectedNewUpdatedAt1->getTimestamp(), $parsedRefetchedUpdatedAt1->getTimestamp());
 
         // updateDocuments with preserved $updatedAt over a subset
-        $bulkCurDate   = '2001-01-01T00:00:00.000+00:00';
+        $bulkCurDate = '2001-01-01T00:00:00.000+00:00';
         $bulkUpdatedAt = '2001-01-02T00:00:00.000+00:00';
         $updatedCount = $database->withPreserveDates(function () use ($database, $col, $bulkCurDate, $bulkUpdatedAt) {
             return $database->updateDocuments(
@@ -1162,10 +1011,10 @@ public function testSchemalessDates(): void
         $bulkUpdatedAt2 = $afterBulk2->getAttribute('$updatedAt');
         $bulkCurDate3 = $afterBulk3->getAttribute('curDate');
         $bulkUpdatedAt3 = $afterBulk3->getAttribute('$updatedAt');
-        $parsedBulkCurDate2 = new \DateTime($bulkCurDate2);
-        $parsedBulkUpdatedAt2 = new \DateTime($bulkUpdatedAt2);
-        $parsedBulkCurDate3 = new \DateTime($bulkCurDate3);
-        $parsedBulkUpdatedAt3 = new \DateTime($bulkUpdatedAt3);
+        $parsedBulkCurDate2 = new \DateTime($this->asString($bulkCurDate2));
+        $parsedBulkUpdatedAt2 = new \DateTime($this->asString($bulkUpdatedAt2));
+        $parsedBulkCurDate3 = new \DateTime($this->asString($bulkCurDate3));
+        $parsedBulkUpdatedAt3 = new \DateTime($this->asString($bulkUpdatedAt3));
         $parsedExpectedBulkCurDate = new \DateTime($bulkCurDate);
         $parsedExpectedBulkUpdatedAt = new \DateTime($bulkUpdatedAt);
         $this->assertEquals($parsedExpectedBulkCurDate->getTimestamp(), $parsedBulkCurDate2->getTimestamp());
@@ -1176,8 +1025,8 @@ public function testSchemalessDates(): void
         // upsertDocument: create new then update existing with preserved dates
         $createdAt4 = '2003-03-03T03:03:03.000+00:00';
         $updatedAt4 = '2003-03-04T04:04:04.000+00:00';
-        $curDate4   = '2003-03-05T05:05:05.000+00:00';
-        $up1 = $database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt4, $updatedAt4, $curDate4) {
+        $curDate4 = '2003-03-05T05:05:05.000+00:00';
+        $up1 = $this->asDocument($database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt4, $updatedAt4, $curDate4) {
             return $database->upsertDocument($col, new Document([
                 '$id' => 'd4',
                 '$permissions' => $permissions,
@@ -1185,14 +1034,14 @@ public function testSchemalessDates(): void
                 '$updatedAt' => $updatedAt4,
                 'curDate' => $curDate4,
             ]));
-        });
+        }));
         $this->assertEquals('d4', $up1->getId());
         $up1CurDate4 = $up1->getAttribute('curDate');
         $up1CreatedAt4 = $up1->getAttribute('$createdAt');
         $up1UpdatedAt4 = $up1->getAttribute('$updatedAt');
-        $parsedUp1CurDate4 = new \DateTime($up1CurDate4);
-        $parsedUp1CreatedAt4 = new \DateTime($up1CreatedAt4);
-        $parsedUp1UpdatedAt4 = new \DateTime($up1UpdatedAt4);
+        $parsedUp1CurDate4 = new \DateTime($this->asString($up1CurDate4));
+        $parsedUp1CreatedAt4 = new \DateTime($this->asString($up1CreatedAt4));
+        $parsedUp1UpdatedAt4 = new \DateTime($this->asString($up1UpdatedAt4));
         $parsedExpectedCurDate4 = new \DateTime($curDate4);
         $parsedExpectedCreatedAt4 = new \DateTime($createdAt4);
         $parsedExpectedUpdatedAt4 = new \DateTime($updatedAt4);
@@ -1201,18 +1050,18 @@ public function testSchemalessDates(): void
         $this->assertEquals($parsedExpectedUpdatedAt4->getTimestamp(), $parsedUp1UpdatedAt4->getTimestamp());
 
         $updatedAt4b = '2003-03-06T06:06:06.000+00:00';
-        $curDate4b   = '2003-03-07T07:07:07.000+00:00';
-        $up2 = $database->withPreserveDates(function () use ($database, $col, $updatedAt4b, $curDate4b) {
+        $curDate4b = '2003-03-07T07:07:07.000+00:00';
+        $up2 = $this->asDocument($database->withPreserveDates(function () use ($database, $col, $updatedAt4b, $curDate4b) {
             return $database->upsertDocument($col, new Document([
                 '$id' => 'd4',
                 'curDate' => $curDate4b,
                 '$updatedAt' => $updatedAt4b,
             ]));
-        });
+        }));
         $up2CurDate4b = $up2->getAttribute('curDate');
         $up2UpdatedAt4b = $up2->getAttribute('$updatedAt');
-        $parsedUp2CurDate4b = new \DateTime($up2CurDate4b);
-        $parsedUp2UpdatedAt4b = new \DateTime($up2UpdatedAt4b);
+        $parsedUp2CurDate4b = new \DateTime($this->asString($up2CurDate4b));
+        $parsedUp2UpdatedAt4b = new \DateTime($this->asString($up2UpdatedAt4b));
         $parsedExpectedCurDate4b = new \DateTime($curDate4b);
         $parsedExpectedUpdatedAt4b = new \DateTime($updatedAt4b);
         $this->assertEquals($parsedExpectedCurDate4b->getTimestamp(), $parsedUp2CurDate4b->getTimestamp());
@@ -1220,17 +1069,17 @@ public function testSchemalessDates(): void
         $refetched4 = $database->getDocument($col, 'd4');
         $refetched4CurDate4b = $refetched4->getAttribute('curDate');
         $refetched4UpdatedAt4b = $refetched4->getAttribute('$updatedAt');
-        $parsedRefetched4CurDate4b = new \DateTime($refetched4CurDate4b);
-        $parsedRefetched4UpdatedAt4b = new \DateTime($refetched4UpdatedAt4b);
+        $parsedRefetched4CurDate4b = new \DateTime($this->asString($refetched4CurDate4b));
+        $parsedRefetched4UpdatedAt4b = new \DateTime($this->asString($refetched4UpdatedAt4b));
         $this->assertEquals($parsedExpectedCurDate4b->getTimestamp(), $parsedRefetched4CurDate4b->getTimestamp());
         $this->assertEquals($parsedExpectedUpdatedAt4b->getTimestamp(), $parsedRefetched4UpdatedAt4b->getTimestamp());
 
         // upsertDocuments: mix create and update with preserved dates
         $createdAt5 = '2004-04-01T01:01:01.000+00:00';
         $updatedAt5 = '2004-04-02T02:02:02.000+00:00';
-        $curDate5   = '2004-04-03T03:03:03.000+00:00';
+        $curDate5 = '2004-04-03T03:03:03.000+00:00';
         $updatedAt2b = '2001-02-08T08:08:08.000+00:00';
-        $curDate2b   = '2001-02-09T09:09:09.000+00:00';
+        $curDate2b = '2001-02-09T09:09:09.000+00:00';
 
         $upCount = $database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt5, $updatedAt5, $curDate5, $updatedAt2b, $curDate2b) {
             return $database->upsertDocuments($col, [
@@ -1254,9 +1103,9 @@ public function testSchemalessDates(): void
         $fetched5CurDate5 = $fetched5->getAttribute('curDate');
         $fetched5CreatedAt5 = $fetched5->getAttribute('$createdAt');
         $fetched5UpdatedAt5 = $fetched5->getAttribute('$updatedAt');
-        $parsedFetched5CurDate5 = new \DateTime($fetched5CurDate5);
-        $parsedFetched5CreatedAt5 = new \DateTime($fetched5CreatedAt5);
-        $parsedFetched5UpdatedAt5 = new \DateTime($fetched5UpdatedAt5);
+        $parsedFetched5CurDate5 = new \DateTime($this->asString($fetched5CurDate5));
+        $parsedFetched5CreatedAt5 = new \DateTime($this->asString($fetched5CreatedAt5));
+        $parsedFetched5UpdatedAt5 = new \DateTime($this->asString($fetched5UpdatedAt5));
         $parsedExpectedCurDate5 = new \DateTime($curDate5);
         $parsedExpectedCreatedAt5 = new \DateTime($createdAt5);
         $parsedExpectedUpdatedAt5 = new \DateTime($updatedAt5);
@@ -1267,8 +1116,8 @@ public function testSchemalessDates(): void
         $fetched2b = $database->getDocument($col, 'd2');
         $fetched2bCurDate2b = $fetched2b->getAttribute('curDate');
         $fetched2bUpdatedAt2b = $fetched2b->getAttribute('$updatedAt');
-        $parsedFetched2bCurDate2b = new \DateTime($fetched2bCurDate2b);
-        $parsedFetched2bUpdatedAt2b = new \DateTime($fetched2bUpdatedAt2b);
+        $parsedFetched2bCurDate2b = new \DateTime($this->asString($fetched2bCurDate2b));
+        $parsedFetched2bUpdatedAt2b = new \DateTime($this->asString($fetched2bUpdatedAt2b));
         $parsedExpectedCurDate2b = new \DateTime($curDate2b);
         $parsedExpectedUpdatedAt2b = new \DateTime($updatedAt2b);
         $this->assertEquals($parsedExpectedCurDate2b->getTimestamp(), $parsedFetched2bCurDate2b->getTimestamp());
@@ -1307,19 +1156,20 @@ public function testSchemalessExists(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $colName = uniqid('schemaless_exists');
-        $database->createCollection($colName);
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create documents with and without the 'optionalField' attribute
@@ -1424,19 +1274,20 @@ public function testSchemalessNotExists(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $colName = uniqid('schemaless_not_exists');
-        $database->createCollection($colName);
+        $database->createCollection(new Collection(id: $colName));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create documents with and without the 'optionalField' attribute
@@ -1534,12 +1385,13 @@ public function testElemMatch(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create documents with array of objects
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -1548,7 +1400,7 @@ public function testElemMatch(): void
             'items' => [
                 ['sku' => 'ABC', 'qty' => 5, 'price' => 10.50],
                 ['sku' => 'XYZ', 'qty' => 2, 'price' => 20.00],
-            ]
+            ],
         ]));
 
         $doc2 = $database->createDocument($collectionId, new Document([
@@ -1557,7 +1409,7 @@ public function testElemMatch(): void
             'items' => [
                 ['sku' => 'ABC', 'qty' => 1, 'price' => 10.50],
                 ['sku' => 'DEF', 'qty' => 10, 'price' => 15.00],
-            ]
+            ],
         ]));
 
         $doc3 = $database->createDocument($collectionId, new Document([
@@ -1565,7 +1417,7 @@ public function testElemMatch(): void
             '$permissions' => [Permission::read(Role::any())],
             'items' => [
                 ['sku' => 'XYZ', 'qty' => 3, 'price' => 20.00],
-            ]
+            ],
         ]));
 
         // Test 1: elemMatch with equal and greaterThan - should match doc1
@@ -1573,7 +1425,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
                 Query::greaterThan('qty', 1),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('order1', $results[0]->getId());
@@ -1583,7 +1435,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
                 Query::greaterThan('qty', 1),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('order1', $results[0]->getId());
@@ -1592,7 +1444,7 @@ public function testElemMatch(): void
         $results = $database->find($collectionId, [
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
         $ids = array_map(fn ($doc) => $doc->getId(), $results);
@@ -1604,7 +1456,7 @@ public function testElemMatch(): void
         $results = $database->find($collectionId, [
             Query::elemMatch('items', [
                 Query::greaterThan('qty', 1),
-            ])
+            ]),
         ]);
         $this->assertCount(3, $results);
         $ids = array_map(fn ($doc) => $doc->getId(), $results);
@@ -1617,7 +1469,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['DEF']),
                 Query::greaterThan('qty', 5),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('order2', $results[0]->getId());
@@ -1627,7 +1479,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
                 Query::lessThan('qty', 3),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('order2', $results[0]->getId());
@@ -1637,7 +1489,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
                 Query::greaterThanEqual('qty', 1),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
 
@@ -1645,7 +1497,7 @@ public function testElemMatch(): void
         $results = $database->find($collectionId, [
             Query::elemMatch('items', [
                 Query::equal('sku', ['NONEXISTENT']),
-            ])
+            ]),
         ]);
         $this->assertCount(0, $results);
 
@@ -1654,7 +1506,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['XYZ']),
                 Query::equal('price', [20.00]),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
         $ids = array_map(fn ($doc) => $doc->getId(), $results);
@@ -1666,7 +1518,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::notEqual('sku', ['ABC']),
                 Query::greaterThan('qty', 2),
-            ])
+            ]),
         ]);
         // order 1 has elements where sku == "ABC", qty: 5 => !=ABC fails and sku = XYZ ,qty: 2 => >2 fails
         $this->assertCount(2, $results);
@@ -1687,12 +1539,13 @@ public function testElemMatchComplex(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
         $collectionId = ID::unique();
-        $database->createCollection($collectionId);
+        $database->createCollection(new Collection(id: $collectionId));
 
         // Create documents with complex nested structures
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -1701,7 +1554,7 @@ public function testElemMatchComplex(): void
             'products' => [
                 ['name' => 'Widget', 'stock' => 100, 'category' => 'A', 'active' => true],
                 ['name' => 'Gadget', 'stock' => 50, 'category' => 'B', 'active' => false],
-            ]
+            ],
         ]));
 
         $doc2 = $database->createDocument($collectionId, new Document([
@@ -1710,7 +1563,7 @@ public function testElemMatchComplex(): void
             'products' => [
                 ['name' => 'Widget', 'stock' => 200, 'category' => 'A', 'active' => true],
                 ['name' => 'Thing', 'stock' => 25, 'category' => 'C', 'active' => true],
-            ]
+            ],
         ]));
 
         // Test: elemMatch with multiple conditions including boolean
@@ -1720,7 +1573,7 @@ public function testElemMatchComplex(): void
                 Query::greaterThan('stock', 50),
                 Query::equal('category', ['A']),
                 Query::equal('active', [true]),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
 
@@ -1729,7 +1582,7 @@ public function testElemMatchComplex(): void
             Query::elemMatch('products', [
                 Query::equal('category', ['A']),
                 Query::between('stock', 75, 150),
-            ])
+            ]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('store1', $results[0]->getId());
@@ -1742,7 +1595,7 @@ public function testElemMatchComplex(): void
                     Query::equal('name', ['Thing']),
                 ]),
                 Query::greaterThanEqual('stock', 25),
-            ])
+            ]),
         ]);
         // Both stores have at least one matching product:
         // - store1: Widget (stock 100)
@@ -1763,7 +1616,7 @@ public function testElemMatchComplex(): void
                     ]),
                 ]),
                 Query::equal('active', [true]),
-            ])
+            ]),
         ]);
         // Only store2 matches:
         // - Widget with stock 200 (>150) and active true
@@ -1782,19 +1635,20 @@ public function testSchemalessNestedObjectAttributeQueries(): void
 
         /** @var Database $database */
         $database = static::getDatabase();
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_nested_obj');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Documents with nested objects
@@ -1960,17 +1814,17 @@ public function testUpsertFieldRemoval(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->markTestSkipped('Adapter supports attributes (schemaful mode). Field removal in upsert is tested in schemaful tests.');
         }
 
         $collectionName = ID::unique();
-        $database->createCollection($collectionName, permissions: [
+        $database->createCollection(new Collection(id: $collectionName, permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
             Permission::update(Role::any()),
             Permission::delete(Role::any()),
-        ]);
+        ]));
 
         $permissions = [
             Permission::read(Role::any()),
@@ -1990,8 +1844,8 @@ public function testUpsertFieldRemoval(): void
             'tags' => ['php', 'mongodb'],
             'metadata' => [
                 'author' => 'John Doe',
-                'version' => 1
-            ]
+                'version' => 1,
+            ],
         ]));
 
         $this->assertEquals('Original Title', $doc1->getAttribute('title'));
@@ -2051,12 +1905,12 @@ public function testUpsertFieldRemoval(): void
             'details' => [
                 'color' => 'red',
                 'size' => 'large',
-                'weight' => 10
+                'weight' => 10,
             ],
             'specs' => [
                 'cpu' => 'Intel',
-                'ram' => '8GB'
-            ]
+                'ram' => '8GB',
+            ],
         ]));
 
         // Upsert removing details but keeping specs
@@ -2066,7 +1920,7 @@ public function testUpsertFieldRemoval(): void
             'name' => 'Updated Product',
             'specs' => [
                 'cpu' => 'AMD',
-                'ram' => '16GB'
+                'ram' => '16GB',
             ],
             // details is removed
         ]));
@@ -2074,7 +1928,7 @@ public function testUpsertFieldRemoval(): void
         $retrieved3 = $database->getDocument($collectionName, 'doc3');
         $this->assertEquals('Updated Product', $retrieved3->getAttribute('name'));
         $this->assertArrayHasKey('specs', $retrieved3->getArrayCopy());
-        $this->assertEquals('AMD', $retrieved3->getAttribute('specs')['cpu']);
+        $this->assertEquals('AMD', $retrieved3->getArray('specs')['cpu']);
         $this->assertArrayNotHasKey('details', $retrieved3->getArrayCopy());
 
         // Test 4: Remove array fields
@@ -2084,7 +1938,7 @@ public function testUpsertFieldRemoval(): void
             'title' => 'Article',
             'tags' => ['tag1', 'tag2', 'tag3'],
             'categories' => ['cat1', 'cat2'],
-            'comments' => ['comment1', 'comment2']
+            'comments' => ['comment1', 'comment2'],
         ]));
 
         // Upsert removing tags and comments but keeping categories
@@ -2245,39 +2099,32 @@ public function testSchemalessTTLIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_ttl');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_valid',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                3600 // 1 hour TTL
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_valid', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 3600))
         );
 
         $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(1, $indexes);
         $ttlIndex = $indexes[0];
         $this->assertEquals('idx_ttl_valid', $ttlIndex->getId());
-        $this->assertEquals(Database::INDEX_TTL, $ttlIndex->getAttribute('type'));
+        $this->assertEquals(IndexType::Ttl->value, $ttlIndex->getAttribute('type'));
         $this->assertEquals(3600, $ttlIndex->getAttribute('ttl'));
 
         $now = new \DateTime();
@@ -2289,21 +2136,21 @@ public function testSchemalessTTLIndexes(): void
             '$id' => 'doc1',
             '$permissions' => $permissions,
             'expiresAt' => $future1->format(\DateTime::ATOM),
-            'data' => 'will expire in 2 hours'
+            'data' => 'will expire in 2 hours',
         ]));
 
         $doc2 = $database->createDocument($col, new Document([
             '$id' => 'doc2',
             '$permissions' => $permissions,
             'expiresAt' => $future2->format(\DateTime::ATOM),
-            'data' => 'will expire in 1 hour'
+            'data' => 'will expire in 1 hour',
         ]));
 
         $doc3 = $database->createDocument($col, new Document([
             '$id' => 'doc3',
             '$permissions' => $permissions,
             'expiresAt' => $past->format(\DateTime::ATOM),
-            'data' => 'already expired'
+            'data' => 'already expired',
         ]));
 
         // Verify documents were created
@@ -2314,43 +2161,19 @@ public function testSchemalessTTLIndexes(): void
         $this->assertTrue($database->deleteIndex($col, 'idx_ttl_valid'));
 
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_min',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                1 // Minimum TTL
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_min', attributes: ['expiresAt'], orders: [Order::Asc]))
         );
 
         $col2 = uniqid('sl_ttl_collection');
 
-        $expiresAtAttr = new Document([
-            '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
-            'size' => 0,
-            'signed' => false,
-            'required' => false,
-            'default' => null,
-            'array' => false,
-            'filters' => ['datetime'],
-        ]);
+        $expiresAtAttr = Attribute::datetime(key: 'expiresAt', signed: false, filters: ['datetime']);
 
-        $ttlIndexDoc = new Document([
-            '$id' => ID::custom('idx_ttl_collection'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200 // 2 hours
-        ]);
+        $ttlIndexDoc = Index::ttl(key: 'idx_ttl_collection', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 7200);
 
-        $database->createCollection($col2, [$expiresAtAttr], [$ttlIndexDoc]);
+        $database->createCollection(new Collection(id: $col2, attributes: [$expiresAtAttr], indexes: [$ttlIndexDoc]));
 
         $collection2 = $database->getCollection($col2);
-        $indexes2 = $collection2->getAttribute('indexes');
+        $indexes2 = $collection2->indexes;
         $this->assertCount(1, $indexes2);
         $ttlIndex2 = $indexes2[0];
         $this->assertEquals('idx_ttl_collection', $ttlIndex2->getId());
@@ -2360,169 +2183,25 @@ public function testSchemalessTTLIndexes(): void
         $database->deleteCollection($col2);
     }
 
-    public function testSchemalessTTLIndexDuplicatePrevention(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $col = uniqid('sl_ttl_dup');
-        $database->createCollection($col);
-
-        $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_expires',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                3600 // 1 hour
-            )
-        );
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_expires_duplicate',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                7200 // 2 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                86400 // 24 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
-        $this->assertCount(1, $indexes);
-
-        $indexIds = array_map(fn ($idx) => $idx->getId(), $indexes);
-        $this->assertContains('idx_ttl_expires', $indexIds);
-        $this->assertNotContains('idx_ttl_deleted', $indexIds);
-
-        try {
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted_duplicate',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                172800 // 48 hours
-            );
-            $this->fail('Expected exception for creating a second TTL index in a collection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        $this->assertTrue($database->deleteIndex($col, 'idx_ttl_expires'));
-
-        $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_deleted',
-                Database::INDEX_TTL,
-                ['deletedAt'],
-                [],
-                [Database::ORDER_ASC],
-                1800 // 30 minutes
-            )
-        );
-
-        $collection = $database->getCollection($col);
-        $indexes = $collection->getAttribute('indexes');
-        $this->assertCount(1, $indexes);
-
-        $indexIds = array_map(fn ($idx) => $idx->getId(), $indexes);
-        $this->assertNotContains('idx_ttl_expires', $indexIds);
-        $this->assertContains('idx_ttl_deleted', $indexIds);
-
-        $col3 = uniqid('sl_ttl_dup_collection');
-
-        $expiresAtAttr = new Document([
-            '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
-            'size' => 0,
-            'signed' => false,
-            'required' => false,
-            'default' => null,
-            'array' => false,
-            'filters' => ['datetime'],
-        ]);
-
-        $ttlIndex1 = new Document([
-            '$id' => ID::custom('idx_ttl_1'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 3600
-        ]);
-
-        $ttlIndex2 = new Document([
-            '$id' => ID::custom('idx_ttl_2'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200
-        ]);
-
-        try {
-            $database->createCollection($col3, [$expiresAtAttr], [$ttlIndex1, $ttlIndex2]);
-            $this->fail('Expected exception for duplicate TTL indexes in createCollection');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
-        }
-
-        $database->deleteCollection($col);
-    }
-
     public function testSchemalessDatetimeCreationAndFetching(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_datetime');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create documents with ISO 8601 datetime strings (20-40 chars)
@@ -2535,21 +2214,21 @@ public function testSchemalessDatetimeCreationAndFetching(): void
             '$id' => 'dt1',
             '$permissions' => $permissions,
             'eventDate' => $datetime1,
-            'name' => 'Event 1'
+            'name' => 'Event 1',
         ]));
 
         $doc2 = $database->createDocument($col, new Document([
             '$id' => 'dt2',
             '$permissions' => $permissions,
             'eventDate' => $datetime2,
-            'name' => 'Event 2'
+            'name' => 'Event 2',
         ]));
 
         $doc3 = $database->createDocument($col, new Document([
             '$id' => 'dt3',
             '$permissions' => $permissions,
             'eventDate' => $datetime3,
-            'name' => 'Event 3'
+            'name' => 'Event 3',
         ]));
 
         // Verify creation - check that datetime is stored and returned as string
@@ -2567,14 +2246,14 @@ public function testSchemalessDatetimeCreationAndFetching(): void
 
         // Verify datetime values are equivalent by parsing (MongoDB converts to UTC)
         $parsedInput1 = new \DateTime($datetime1);
-        $parsedOutput1 = new \DateTime($fetchedEventDate1);
+        $parsedOutput1 = new \DateTime($this->asString($fetchedEventDate1));
         $this->assertEquals($parsedInput1->getTimestamp(), $parsedOutput1->getTimestamp());
 
         $fetched2 = $database->getDocument($col, 'dt2');
         $fetchedEventDate2 = $fetched2->getAttribute('eventDate');
         $this->assertTrue(is_string($fetchedEventDate2));
         $parsedInput2 = new \DateTime($datetime2);
-        $parsedOutput2 = new \DateTime($fetchedEventDate2);
+        $parsedOutput2 = new \DateTime($this->asString($fetchedEventDate2));
         $this->assertEquals($parsedInput2->getTimestamp(), $parsedOutput2->getTimestamp());
 
         $fetched3 = $database->getDocument($col, 'dt3');
@@ -2583,8 +2262,8 @@ public function testSchemalessDatetimeCreationAndFetching(): void
         // Verify it's a valid datetime string (format may vary slightly)
         $this->assertGreaterThanOrEqual(20, strlen($fetchedEventDate3));
         $this->assertLessThanOrEqual(40, strlen($fetchedEventDate3));
-        $parsedInput3 = new \DateTime($datetime3);
-        $parsedOutput3 = new \DateTime($fetchedEventDate3);
+        $parsedInput3 = new \DateTime($this->asString($datetime3));
+        $parsedOutput3 = new \DateTime($this->asString($fetchedEventDate3));
         // MongoDB converts to UTC, so timestamps should match
         $this->assertEquals($parsedInput3->getTimestamp(), $parsedOutput3->getTimestamp());
 
@@ -2601,7 +2280,7 @@ public function testSchemalessDatetimeCreationAndFetching(): void
         // Update datetime
         $newDatetime = '2024-12-31T23:59:59.999+00:00';
         $updated = $database->updateDocument($col, 'dt1', new Document([
-            'eventDate' => $newDatetime
+            'eventDate' => $newDatetime,
         ]));
         $updatedEventDate = $updated->getAttribute('eventDate');
         $this->assertTrue(is_string($updatedEventDate));
@@ -2612,7 +2291,7 @@ public function testSchemalessDatetimeCreationAndFetching(): void
         $refetchedEventDate = $refetched->getAttribute('eventDate');
         $this->assertTrue(is_string($refetchedEventDate));
         $parsedNewInput = new \DateTime($newDatetime);
-        $parsedNewOutput = new \DateTime($refetchedEventDate);
+        $parsedNewOutput = new \DateTime($this->asString($refetchedEventDate));
         $this->assertEquals($parsedNewInput->getTimestamp(), $parsedNewOutput->getTimestamp());
 
         $database->deleteCollection($col);
@@ -2623,37 +2302,31 @@ public function testSchemalessTTLExpiry(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForTTLIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::TTLIndexes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_ttl_expiry');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create TTL index with 60 seconds expiry
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_expiresAt',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                10
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_expiresAt', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -2666,7 +2339,7 @@ public function testSchemalessTTLExpiry(): void
             '$permissions' => $permissions,
             'expiresAt' => $expiredTime->format(\DateTime::ATOM),
             'data' => 'This should expire',
-            'type' => 'temporary'
+            'type' => 'temporary',
         ]));
 
         $doc2 = $database->createDocument($col, new Document([
@@ -2674,21 +2347,21 @@ public function testSchemalessTTLExpiry(): void
             '$permissions' => $permissions,
             'expiresAt' => $futureTime->format(\DateTime::ATOM),
             'data' => 'This should not expire yet',
-            'type' => 'temporary'
+            'type' => 'temporary',
         ]));
 
         $doc3 = $database->createDocument($col, new Document([
             '$id' => 'permanent_doc',
             '$permissions' => $permissions,
             'data' => 'This should never expire',
-            'type' => 'permanent'
+            'type' => 'permanent',
         ]));
 
         $doc4 = $database->createDocument($col, new Document([
             '$id' => 'another_permanent',
             '$permissions' => $permissions,
             'data' => 'This should also never expire',
-            'type' => 'permanent'
+            'type' => 'permanent',
         ]));
 
         // Verify all documents were created
@@ -2711,14 +2384,13 @@ public function testSchemalessTTLExpiry(): void
             sleep($retryDelay);
 
             // Fetch collection to trigger TTL cleanup check
-            $collection = $database->getCollection($col);
-            $this->assertNotNull($collection);
+            $database->getCollection($col);
 
             // Check if expired document is gone
             $remainingDocs = $database->find($col);
             $remainingIds = array_map(fn ($doc) => $doc->getId(), $remainingDocs);
 
-            if (!in_array('expired_doc', $remainingIds)) {
+            if (! in_array('expired_doc', $remainingIds)) {
                 $expiredDocDeleted = true;
                 break;
             }
@@ -2765,37 +2437,31 @@ public function testSchemalessTTLWithCacheExpiry(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForTTLIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::TTLIndexes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_ttl_cache_expiry');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create TTL index with 10 seconds expiry (also used as cache TTL)
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_expiresAt',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                10
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_expiresAt', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -2831,8 +2497,7 @@ public function testSchemalessTTLWithCacheExpiry(): void
             sleep($retryDelay);
 
             // Fetch collection to trigger TTL cleanup check in MongoDB
-            $collection = $database->getCollection($col);
-            $this->assertNotNull($collection);
+            $database->getCollection($col);
 
             // Fetch through getDocument, which goes through the cache layer
             $expired = $database->getDocument($col, 'expired_doc');
@@ -2858,19 +2523,20 @@ public function testStringAndDatetime(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_str_datetime');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create documents with mix of formatted dates (ISO 8601) and non-formatted dates (regular strings)
@@ -2880,31 +2546,31 @@ public function testStringAndDatetime(): void
                 '$id' => 'doc1',
                 '$permissions' => $permissions,
                 'str' => '2024-01-15T10:30:00.000+00:00', // ISO 8601 formatted date as string
-                'datetime' => '2024-01-15T10:30:00.000+00:00' // ISO 8601 formatted date
+                'datetime' => '2024-01-15T10:30:00.000+00:00', // ISO 8601 formatted date
             ]),
             new Document([
                 '$id' => 'doc2',
                 '$permissions' => $permissions,
                 'str' => 'just a regular string', // Non-formatted string
-                'datetime' => '2024-02-20T14:45:30.123Z' // ISO 8601 formatted date
+                'datetime' => '2024-02-20T14:45:30.123Z', // ISO 8601 formatted date
             ]),
             new Document([
                 '$id' => 'doc3',
                 '$permissions' => $permissions,
                 'str' => '2024-03-25T08:15:45.000000+05:30', // ISO 8601 formatted date as string
-                'datetime' => 'not a date string' // Non-formatted string in datetime field
+                'datetime' => 'not a date string', // Non-formatted string in datetime field
             ]),
             new Document([
                 '$id' => 'doc4',
                 '$permissions' => $permissions,
                 'str' => 'another string value',
-                'datetime' => '2024-12-31T23:59:59.999+00:00' // ISO 8601 formatted date
+                'datetime' => '2024-12-31T23:59:59.999+00:00', // ISO 8601 formatted date
             ]),
             new Document([
                 '$id' => 'doc5',
                 '$permissions' => $permissions,
                 'str' => '2024-06-15T12:00:00.000Z', // ISO 8601 formatted date as string
-                'datetime' => '2024-06-15T12:00:00.000Z' // ISO 8601 formatted date
+                'datetime' => '2024-06-15T12:00:00.000Z', // ISO 8601 formatted date
             ]),
         ];
 
@@ -2924,21 +2590,17 @@ public function testStringAndDatetime(): void
         $this->assertGreaterThanOrEqual(20, strlen($doc1->getAttribute('str')));
         $this->assertLessThanOrEqual(40, strlen($doc1->getAttribute('str')));
         // datetime field should be converted to MongoDB format if it's a valid ISO date
-        $datetime1 = $doc1->getAttribute('datetime');
-        $this->assertTrue(is_string($datetime1));
+        $datetime1 = $this->asString($doc1->getAttribute('datetime'));
         $this->assertGreaterThanOrEqual(20, strlen($datetime1));
         $this->assertLessThanOrEqual(40, strlen($datetime1));
         // Verify it's a valid datetime by parsing
         $parsed1 = new \DateTime($datetime1);
-        $this->assertInstanceOf(\DateTime::class, $parsed1);
 
         $doc2 = $database->getDocument($col, 'doc2');
         $this->assertEquals('doc2', $doc2->getId());
         $this->assertEquals('just a regular string', $doc2->getAttribute('str'));
-        $datetime2 = $doc2->getAttribute('datetime');
-        $this->assertTrue(is_string($datetime2));
+        $datetime2 = $this->asString($doc2->getAttribute('datetime'));
         $parsed2 = new \DateTime($datetime2);
-        $this->assertInstanceOf(\DateTime::class, $parsed2);
 
         $doc3 = $database->getDocument($col, 'doc3');
         $this->assertEquals('doc3', $doc3->getId());
@@ -2954,10 +2616,8 @@ public function testStringAndDatetime(): void
         $doc4 = $database->getDocument($col, 'doc4');
         $this->assertEquals('doc4', $doc4->getId());
         $this->assertEquals('another string value', $doc4->getAttribute('str'));
-        $datetime4 = $doc4->getAttribute('datetime');
-        $this->assertTrue(is_string($datetime4));
+        $datetime4 = $this->asString($doc4->getAttribute('datetime'));
         $parsed4 = new \DateTime($datetime4);
-        $this->assertInstanceOf(\DateTime::class, $parsed4);
 
         $doc5 = $database->getDocument($col, 'doc5');
         $this->assertEquals('doc5', $doc5->getId());
@@ -2965,10 +2625,8 @@ public function testStringAndDatetime(): void
         $this->assertTrue(is_string($str5));
         $this->assertGreaterThanOrEqual(20, strlen($str5));
         $this->assertLessThanOrEqual(40, strlen($str5));
-        $datetime5 = $doc5->getAttribute('datetime');
-        $this->assertTrue(is_string($datetime5));
+        $datetime5 = $this->asString($doc5->getAttribute('datetime'));
         $parsed5 = new \DateTime($datetime5);
-        $this->assertInstanceOf(\DateTime::class, $parsed5);
 
         // Verify all documents are present using simple find
         $allDocs = $database->find($col);
@@ -2988,37 +2646,31 @@ public function testStringAndDateWithTTL(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForTTLIndexes()) {
+        if (! $database->getAdapter()->supports(Capability::TTLIndexes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_str_date_ttl');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Create TTL index on expiresAt field
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_ttl_expiresAt',
-                Database::INDEX_TTL,
-                ['expiresAt'],
-                [],
-                [Database::ORDER_ASC],
-                10
-            )
+            $database->createIndex($col, Index::ttl(key: 'idx_ttl_expiresAt', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -3032,35 +2684,35 @@ public function testStringAndDateWithTTL(): void
                 '$permissions' => $permissions,
                 'expiresAt' => $expiredTime->format(\DateTime::ATOM), // Valid datetime - should expire
                 'data' => 'This should expire',
-                'type' => 'datetime'
+                'type' => 'datetime',
             ]),
             new Document([
                 '$id' => 'doc_datetime_future',
                 '$permissions' => $permissions,
                 'expiresAt' => $futureTime->format(\DateTime::ATOM), // Valid datetime - future
                 'data' => 'This should not expire yet',
-                'type' => 'datetime'
+                'type' => 'datetime',
             ]),
             new Document([
                 '$id' => 'doc_string_random',
                 '$permissions' => $permissions,
                 'expiresAt' => 'random_string_value_12345', // Random string - should not expire
                 'data' => 'This should never expire',
-                'type' => 'string'
+                'type' => 'string',
             ]),
             new Document([
                 '$id' => 'doc_string_another',
                 '$permissions' => $permissions,
                 'expiresAt' => 'another_random_string_xyz', // Random string - should not expire
                 'data' => 'This should also never expire',
-                'type' => 'string'
+                'type' => 'string',
             ]),
             new Document([
                 '$id' => 'doc_datetime_valid',
                 '$permissions' => $permissions,
                 'expiresAt' => $futureTime->format(\DateTime::ATOM), // Valid datetime - future
                 'data' => 'This is a valid datetime',
-                'type' => 'datetime'
+                'type' => 'datetime',
             ]),
         ];
 
@@ -3078,10 +2730,8 @@ public function testStringAndDateWithTTL(): void
 
         $docDatetimeFuture = $database->getDocument($col, 'doc_datetime_future');
         $this->assertFalse($docDatetimeFuture->isEmpty());
-        $expiresAt2 = $docDatetimeFuture->getAttribute('expiresAt');
-        $this->assertTrue(is_string($expiresAt2));
+        $expiresAt2 = $this->asString($docDatetimeFuture->getAttribute('expiresAt'));
         $parsed2 = new \DateTime($expiresAt2);
-        $this->assertInstanceOf(\DateTime::class, $parsed2);
 
         // Verify documents with random strings remain as strings
         $docStringRandom = $database->getDocument($col, 'doc_string_random');
@@ -3107,13 +2757,12 @@ public function testStringAndDateWithTTL(): void
             sleep($retryDelay);
 
             // Fetch collection to trigger TTL cleanup check
-            $collection = $database->getCollection($col);
-            $this->assertNotNull($collection);
+            $database->getCollection($col);
 
             $remainingDocs = $database->find($col);
             $remainingIds = array_map(fn ($doc) => $doc->getId(), $remainingDocs);
 
-            if (!in_array('doc_datetime_expired', $remainingIds)) {
+            if (! in_array('doc_datetime_expired', $remainingIds)) {
                 $expiredDocDeleted = true;
                 break;
             }
@@ -3158,16 +2807,17 @@ public function testSchemalessMongoDotNotationIndexes(): void
         $database = static::getDatabase();
 
         // Only meaningful for schemaless adapters
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_mongo_dot_idx');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         // Define top-level object attribute (metadata only; schemaless adapter won't enforce)
-        $database->createAttribute($col, 'profile', Database::VAR_OBJECT, 0, false);
+        $database->createAttribute($col, Attribute::object(key: 'profile'));
 
         // Seed documents
         $database->createDocuments($col, [
@@ -3177,9 +2827,9 @@ public function testSchemalessMongoDotNotationIndexes(): void
                 'profile' => [
                     'user' => [
                         'email' => 'alice@example.com',
-                        'id' => 'alice'
-                    ]
-                ]
+                        'id' => 'alice',
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'u2',
@@ -3187,34 +2837,20 @@ public function testSchemalessMongoDotNotationIndexes(): void
                 'profile' => [
                     'user' => [
                         'email' => 'bob@example.com',
-                        'id' => 'bob'
-                    ]
-                ]
+                        'id' => 'bob',
+                    ],
+                ],
             ]),
         ]);
 
         // Create KEY index on nested path
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_profile_user_email_key',
-                Database::INDEX_KEY,
-                ['profile.user.email'],
-                [0],
-                [Database::ORDER_ASC]
-            )
+            $database->createIndex($col, Index::key(key: 'idx_profile_user_email_key', attributes: ['profile.user.email'], lengths: [0], orders: [Order::Asc]))
         );
 
         // Create UNIQUE index on nested path and verify enforcement
         $this->assertTrue(
-            $database->createIndex(
-                $col,
-                'idx_profile_user_id_unique',
-                Database::INDEX_UNIQUE,
-                ['profile.user.id'],
-                [0],
-                [Database::ORDER_ASC]
-            )
+            $database->createIndex($col, Index::unique(key: 'idx_profile_user_id_unique', attributes: ['profile.user.id'], lengths: [0], orders: [Order::Asc]))
         );
 
         try {
@@ -3224,9 +2860,9 @@ public function testSchemalessMongoDotNotationIndexes(): void
                 'profile' => [
                     'user' => [
                         'email' => 'eve@example.com',
-                        'id' => 'alice' // duplicate unique nested id
-                    ]
-                ]
+                        'id' => 'alice', // duplicate unique nested id
+                    ],
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -3235,7 +2871,7 @@ public function testSchemalessMongoDotNotationIndexes(): void
 
         // Validate dot-notation querying works (and is the shape that can use indexes)
         $results = $database->find($col, [
-            Query::equal('profile.user.email', ['bob@example.com'])
+            Query::equal('profile.user.email', ['bob@example.com']),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('u2', $results[0]->getId());
@@ -3248,19 +2884,20 @@ public function testQueryWithDatetime(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = uniqid('sl_query_datetime');
-        $database->createCollection($col);
+        $database->createCollection(new Collection(id: $col));
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         // Documents with datetime field (ISO 8601) for query tests
@@ -3270,13 +2907,13 @@ public function testQueryWithDatetime(): void
                 '$id' => 'dt1',
                 '$permissions' => $permissions,
                 'name' => 'January',
-                'datetime' => '2024-01-15T10:30:00.000+00:00'
+                'datetime' => '2024-01-15T10:30:00.000+00:00',
             ]),
             new Document([
                 '$id' => 'dt2',
                 '$permissions' => $permissions,
                 'name' => 'February',
-                'datetime' => '2024-02-20T14:45:30.123Z'
+                'datetime' => '2024-02-20T14:45:30.123Z',
             ]),
             new Document([
                 '$id' => 'dt3',
@@ -3284,19 +2921,19 @@ public function testQueryWithDatetime(): void
                 'name' => 'March',
                 // Use a valid extended ISO 8601 datetime that will be normalized
                 // to MongoDB UTCDateTime for comparison queries.
-                'datetime' => '2024-03-25T08:15:45.000+00:00'
+                'datetime' => '2024-03-25T08:15:45.000+00:00',
             ]),
             new Document([
                 '$id' => 'dt4',
                 '$permissions' => $permissions,
                 'name' => 'June',
-                'datetime' => '2024-06-15T12:00:00.000Z'
+                'datetime' => '2024-06-15T12:00:00.000Z',
             ]),
             new Document([
                 '$id' => 'dt5',
                 '$permissions' => $permissions,
                 'name' => 'December',
-                'datetime' => '2024-12-31T23:59:59.999+00:00'
+                'datetime' => '2024-12-31T23:59:59.999+00:00',
             ]),
         ];
 
@@ -3305,7 +2942,7 @@ public function testQueryWithDatetime(): void
 
         // Query: equal - find document with exact datetime (Jan 15 2024)
         $equalResults = $database->find($col, [
-            Query::equal('datetime', ['2024-01-15T10:30:00.000+00:00'])
+            Query::equal('datetime', ['2024-01-15T10:30:00.000+00:00']),
         ]);
         $this->assertCount(1, $equalResults);
         $this->assertEquals('dt1', $equalResults[0]->getId());
@@ -3313,7 +2950,7 @@ public function testQueryWithDatetime(): void
 
         // Query: greaterThan - datetimes after 2024-03-01 (dt3, dt4, dt5)
         $greaterResults = $database->find($col, [
-            Query::greaterThan('datetime', '2024-03-01T00:00:00.000Z')
+            Query::greaterThan('datetime', '2024-03-01T00:00:00.000Z'),
         ]);
         $this->assertCount(3, $greaterResults);
         $greaterIds = array_map(fn ($d) => $d->getId(), $greaterResults);
@@ -3323,7 +2960,7 @@ public function testQueryWithDatetime(): void
 
         // Query: lessThan - datetimes before 2024-03-01 (dt1, dt2)
         $lessResults = $database->find($col, [
-            Query::lessThan('datetime', '2024-03-01T00:00:00.000Z')
+            Query::lessThan('datetime', '2024-03-01T00:00:00.000Z'),
         ]);
         $this->assertCount(2, $lessResults);
         $lessIds = array_map(fn ($d) => $d->getId(), $lessResults);
@@ -3332,7 +2969,7 @@ public function testQueryWithDatetime(): void
 
         // Query: greaterThanEqual - datetimes on or after 2024-02-20 (dt2, dt3, dt4, dt5)
         $gteResults = $database->find($col, [
-            Query::greaterThanEqual('datetime', '2024-02-20T14:45:30.123Z')
+            Query::greaterThanEqual('datetime', '2024-02-20T14:45:30.123Z'),
         ]);
         $this->assertCount(4, $gteResults);
         $gteIds = array_map(fn ($d) => $d->getId(), $gteResults);
@@ -3343,7 +2980,7 @@ public function testQueryWithDatetime(): void
 
         // Query: lessThanEqual - datetimes on or before 2024-06-15 (dt1, dt2, dt3, dt4)
         $lteResults = $database->find($col, [
-            Query::lessThanEqual('datetime', '2024-06-15T12:00:00.000Z')
+            Query::lessThanEqual('datetime', '2024-06-15T12:00:00.000Z'),
         ]);
         $this->assertCount(4, $lteResults);
         $lteIds = array_map(fn ($d) => $d->getId(), $lteResults);
@@ -3354,7 +2991,7 @@ public function testQueryWithDatetime(): void
 
         // Query: between - datetimes in range [2024-02-01, 2024-07-01) (dt2, dt3, dt4)
         $betweenResults = $database->find($col, [
-            Query::between('datetime', '2024-02-01T00:00:00.000Z', '2024-07-01T00:00:00.000Z')
+            Query::between('datetime', '2024-02-01T00:00:00.000Z', '2024-07-01T00:00:00.000Z'),
         ]);
         $this->assertCount(3, $betweenResults);
         $betweenIds = array_map(fn ($d) => $d->getId(), $betweenResults);
@@ -3364,7 +3001,7 @@ public function testQueryWithDatetime(): void
 
         // Query: equal with no match
         $noneResults = $database->find($col, [
-            Query::equal('datetime', ['2020-01-01T00:00:00.000Z'])
+            Query::equal('datetime', ['2020-01-01T00:00:00.000Z']),
         ]);
         $this->assertCount(0, $noneResults);
 
@@ -3376,18 +3013,19 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create a simple schemaless collection and one document.
-        $database->createCollection('schemaless_time', permissions: [
+        $database->createCollection(new Collection(id: 'schemaless_time', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
             Permission::delete(Role::any()),
-        ]);
+        ]));
 
         $database->createDocument('schemaless_time', new Document([
             '$id' => ID::unique(),
@@ -3400,7 +3038,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         $recentPastDate = '2020-01-01T00:00:00.000Z';
         $nearFutureDate = '2025-01-01T00:00:00.000Z';
 
-        // --- createdBefore ---
+        // createdBefore
         $documents = $database->find('schemaless_time', [
             Query::createdBefore($futureDate),
             Query::limit(1),
@@ -3413,7 +3051,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         ]);
         $this->assertEquals(0, count($documents));
 
-        // --- createdAfter ---
+        // createdAfter
         $documents = $database->find('schemaless_time', [
             Query::createdAfter($pastDate),
             Query::limit(1),
@@ -3426,7 +3064,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         ]);
         $this->assertEquals(0, count($documents));
 
-        // --- updatedBefore ---
+        // updatedBefore
         $documents = $database->find('schemaless_time', [
             Query::updatedBefore($futureDate),
             Query::limit(1),
@@ -3439,7 +3077,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         ]);
         $this->assertEquals(0, count($documents));
 
-        // --- updatedAfter ---
+        // updatedAfter
         $documents = $database->find('schemaless_time', [
             Query::updatedAfter($pastDate),
             Query::limit(1),
@@ -3452,7 +3090,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         ]);
         $this->assertEquals(0, count($documents));
 
-        // --- createdBetween ---
+        // createdBetween
         $documents = $database->find('schemaless_time', [
             Query::createdBetween($pastDate, $futureDate),
             Query::limit(25),
@@ -3477,7 +3115,7 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         ]);
         $this->assertGreaterThanOrEqual($count, count($documents));
 
-        // --- updatedBetween ---
+        // updatedBetween
         $documents = $database->find('schemaless_time', [
             Query::updatedBetween($pastDate, $futureDate),
             Query::limit(25),
diff --git a/tests/e2e/Adapter/Scopes/SpatialTests.php b/tests/e2e/Adapter/Scopes/SpatialTests.php
index 9a82de6b9c..f19b0fefbd 100644
--- a/tests/e2e/Adapter/Scopes/SpatialTests.php
+++ b/tests/e2e/Adapter/Scopes/SpatialTests.php
@@ -2,16 +2,24 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
-use Utopia\Database\Exception\Index as IndexException;
-use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
 
 trait SpatialTests
 {
@@ -19,73 +27,40 @@ public function testSpatialCollection(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        $collectionName = "test_spatial_Col";
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        $collectionName = 'test_spatial_Col';
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
-        };
+        }
         $attributes = [
-            new Document([
-                '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('attribute2'),
-                'type' => Database::VAR_POINT,
-                'size' => 0,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ])
+            Attribute::string(key: 'attribute1', size: 256),
+            Attribute::point(key: 'attribute2', required: true),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['attribute1'],
-                'lengths' => [256],
-                'orders' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('index2'),
-                'type' => Database::INDEX_SPATIAL,
-                'attributes' => ['attribute2'],
-                'lengths' => [],
-                'orders' => [],
-            ]),
+            Index::key(key: 'index1', attributes: ['attribute1'], lengths: [256]),
+            Index::spatial(key: 'index2', attributes: ['attribute2']),
         ];
 
-        $col =  $database->createCollection($collectionName, $attributes, $indexes);
+        $col = $database->createCollection(new Collection(id: $collectionName, attributes: $attributes, indexes: $indexes));
 
-        $this->assertIsArray($col->getAttribute('attributes'));
-        $this->assertCount(2, $col->getAttribute('attributes'));
+        $this->assertCount(2, $col->attributes);
 
-        $this->assertIsArray($col->getAttribute('indexes'));
-        $this->assertCount(2, $col->getAttribute('indexes'));
+        $this->assertCount(2, $col->indexes);
 
         $col = $database->getCollection($collectionName);
-        $this->assertIsArray($col->getAttribute('attributes'));
-        $this->assertCount(2, $col->getAttribute('attributes'));
+        $this->assertCount(2, $col->attributes);
 
-        $this->assertIsArray($col->getAttribute('indexes'));
-        $this->assertCount(2, $col->getAttribute('indexes'));
+        $this->assertCount(2, $col->indexes);
 
-        $database->createAttribute($collectionName, 'attribute3', Database::VAR_POINT, 0, true);
-        $database->createIndex($collectionName, ID::custom("index3"), Database::INDEX_SPATIAL, ['attribute3']);
+        $database->createAttribute($collectionName, Attribute::point(key: 'attribute3', required: true));
+        $database->createIndex($collectionName, Index::spatial(key: ID::custom('index3'), attributes: ['attribute3']));
 
         $col = $database->getCollection($collectionName);
-        $this->assertIsArray($col->getAttribute('attributes'));
-        $this->assertCount(3, $col->getAttribute('attributes'));
+        $this->assertCount(3, $col->attributes);
 
-        $this->assertIsArray($col->getAttribute('indexes'));
-        $this->assertCount(3, $col->getAttribute('indexes'));
+        $this->assertCount(3, $col->indexes);
 
         $database->deleteCollection($collectionName);
     }
@@ -94,8 +69,9 @@ public function testSpatialTypeDocuments(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -103,17 +79,17 @@ public function testSpatialTypeDocuments(): void
         try {
 
             // Create collection first
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
             // Create spatial attributes using createAttribute method
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'pointAttr', Database::VAR_POINT, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'lineAttr', Database::VAR_LINESTRING, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'polyAttr', Database::VAR_POLYGON, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'pointAttr', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::linestring(key: 'lineAttr', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'polyAttr', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
 
             // Create spatial indexes
-            $this->assertEquals(true, $database->createIndex($collectionName, 'point_spatial', Database::INDEX_SPATIAL, ['pointAttr']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'line_spatial', Database::INDEX_SPATIAL, ['lineAttr']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'poly_spatial', Database::INDEX_SPATIAL, ['polyAttr']));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'point_spatial', attributes: ['pointAttr'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'line_spatial', attributes: ['lineAttr'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'poly_spatial', attributes: ['polyAttr'])));
 
             $point = [5.0, 5.0];
             $linestring = [[1.0, 2.0], [3.0, 4.0]];
@@ -125,16 +101,14 @@ public function testSpatialTypeDocuments(): void
                 'pointAttr' => $point,
                 'lineAttr' => $linestring,
                 'polyAttr' => $polygon,
-                '$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())]
+                '$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())],
             ]);
             $createdDoc = $database->createDocument($collectionName, $doc1);
-            $this->assertInstanceOf(Document::class, $createdDoc);
             $this->assertEquals($point, $createdDoc->getAttribute('pointAttr'));
             $this->assertEquals($linestring, $createdDoc->getAttribute('lineAttr'));
             $this->assertEquals($polygon, $createdDoc->getAttribute('polyAttr'));
 
             $createdDoc = $database->getDocument($collectionName, 'doc1');
-            $this->assertInstanceOf(Document::class, $createdDoc);
             $this->assertEquals($point, $createdDoc->getAttribute('pointAttr'));
             $this->assertEquals($linestring, $createdDoc->getAttribute('lineAttr'));
             $this->assertEquals($polygon, $createdDoc->getAttribute('polyAttr'));
@@ -145,7 +119,6 @@ public function testSpatialTypeDocuments(): void
 
             $this->assertEquals([6.0, 6.0], $updatedDoc->getAttribute('pointAttr'));
 
-
             // Test spatial queries with appropriate operations for each geometry type
             // Point attribute tests - use operations valid for points
             $pointQueries = [
@@ -154,30 +127,30 @@ public function testSpatialTypeDocuments(): void
                 'distanceEqual' => Query::distanceEqual('pointAttr', [5.0, 5.0], 1.4142135623730951),
                 'distanceNotEqual' => Query::distanceNotEqual('pointAttr', [1.0, 1.0], 0.0),
                 'intersects' => Query::intersects('pointAttr', [6.0, 6.0]),
-                'notIntersects' => Query::notIntersects('pointAttr', [1.0, 1.0])
+                'notIntersects' => Query::notIntersects('pointAttr', [1.0, 1.0]),
             ];
 
             foreach ($pointQueries as $queryType => $query) {
-                $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
+                $result = $database->find($collectionName, [$query], PermissionType::Read);
                 $this->assertNotEmpty($result, sprintf('Failed spatial query: %s on pointAttr', $queryType));
                 $this->assertEquals('doc1', $result[0]->getId(), sprintf('Incorrect document returned for %s on pointAttr', $queryType));
             }
 
             // LineString attribute tests - use operations valid for linestrings
             $lineQueries = [
-                'contains' => Query::contains('lineAttr', [[1.0, 2.0]]), // Point on the line (endpoint)
-                'notContains' => Query::notContains('lineAttr', [[5.0, 6.0]]), // Point not on the line
+                'contains' => Query::covers('lineAttr', [[1.0, 2.0]]), // Point on the line (endpoint)
+                'notContains' => Query::notCovers('lineAttr', [[5.0, 6.0]]), // Point not on the line
                 'equals' => query::equal('lineAttr', [[[1.0, 2.0], [3.0, 4.0]]]), // Exact same linestring
                 'notEquals' => query::notEqual('lineAttr', [[[5.0, 6.0], [7.0, 8.0]]]), // Different linestring
                 'intersects' => Query::intersects('lineAttr', [1.0, 2.0]), // Point on the line should intersect
-                'notIntersects' => Query::notIntersects('lineAttr', [5.0, 6.0]) // Point not on the line should not intersect
+                'notIntersects' => Query::notIntersects('lineAttr', [5.0, 6.0]), // Point not on the line should not intersect
             ];
 
             foreach ($lineQueries as $queryType => $query) {
-                if (!$database->getAdapter()->getSupportForBoundaryInclusiveContains() && in_array($queryType, ['contains','notContains'])) {
+                if (! $database->getAdapter()->supports(Capability::BoundaryInclusive) && in_array($queryType, ['contains', 'notContains'])) {
                     continue;
                 }
-                $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
+                $result = $database->find($collectionName, [$query], PermissionType::Read);
                 $this->assertNotEmpty($result, sprintf('Failed spatial query: %s on polyAttr', $queryType));
                 $this->assertEquals('doc1', $result[0]->getId(), sprintf('Incorrect document returned for %s on polyAttr', $queryType));
             }
@@ -187,19 +160,19 @@ public function testSpatialTypeDocuments(): void
                 'distanceEqual' => Query::distanceEqual('lineAttr', [[1.0, 2.0], [3.0, 4.0]], 0.0),
                 'distanceNotEqual' => Query::distanceNotEqual('lineAttr', [[5.0, 6.0], [7.0, 8.0]], 0.0),
                 'distanceLessThan' => Query::distanceLessThan('lineAttr', [[1.0, 2.0], [3.0, 4.0]], 0.1),
-                'distanceGreaterThan' => Query::distanceGreaterThan('lineAttr', [[5.0, 6.0], [7.0, 8.0]], 0.1)
+                'distanceGreaterThan' => Query::distanceGreaterThan('lineAttr', [[5.0, 6.0], [7.0, 8.0]], 0.1),
             ];
 
             foreach ($lineDistanceQueries as $queryType => $query) {
-                $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
+                $result = $database->find($collectionName, [$query], PermissionType::Read);
                 $this->assertNotEmpty($result, sprintf('Failed distance query: %s on lineAttr', $queryType));
                 $this->assertEquals('doc1', $result[0]->getId(), sprintf('Incorrect document for distance %s on lineAttr', $queryType));
             }
 
             // Polygon attribute tests - use operations valid for polygons
             $polyQueries = [
-                'contains' => Query::contains('polyAttr', [[5.0, 5.0]]), // Point inside polygon
-                'notContains' => Query::notContains('polyAttr', [[15.0, 15.0]]), // Point outside polygon
+                'contains' => Query::covers('polyAttr', [[5.0, 5.0]]), // Point inside polygon
+                'notContains' => Query::notCovers('polyAttr', [[15.0, 15.0]]), // Point outside polygon
                 'intersects' => Query::intersects('polyAttr', [0.0, 0.0]), // Point inside polygon should intersect
                 'notIntersects' => Query::notIntersects('polyAttr', [15.0, 15.0]), // Point outside polygon should not intersect
                 'equals' => query::equal('polyAttr', [[
@@ -208,19 +181,19 @@ public function testSpatialTypeDocuments(): void
                         [0.0, 10.0],
                         [10.0, 10.0],
                         [10.0, 0.0],
-                        [0.0, 0.0]
-                    ]
+                        [0.0, 0.0],
+                    ],
                 ]]), // Exact same polygon
                 'notEquals' => query::notEqual('polyAttr', [[[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [20.0, 20.0]]]]), // Different polygon
                 'overlaps' => Query::overlaps('polyAttr', [[[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0], [5.0, 5.0]]]), // Overlapping polygon
-                'notOverlaps' => Query::notOverlaps('polyAttr', [[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [30.0, 20.0], [20.0, 20.0]]]) // Non-overlapping polygon
+                'notOverlaps' => Query::notOverlaps('polyAttr', [[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [30.0, 20.0], [20.0, 20.0]]]), // Non-overlapping polygon
             ];
 
             foreach ($polyQueries as $queryType => $query) {
-                if (!$database->getAdapter()->getSupportForBoundaryInclusiveContains() && in_array($queryType, ['contains','notContains'])) {
+                if (! $database->getAdapter()->supports(Capability::BoundaryInclusive) && in_array($queryType, ['contains', 'notContains'])) {
                     continue;
                 }
-                $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
+                $result = $database->find($collectionName, [$query], PermissionType::Read);
                 $this->assertNotEmpty($result, sprintf('Failed spatial query: %s on polyAttr', $queryType));
                 $this->assertEquals('doc1', $result[0]->getId(), sprintf('Incorrect document returned for %s on polyAttr', $queryType));
             }
@@ -230,11 +203,11 @@ public function testSpatialTypeDocuments(): void
                 'distanceEqual' => Query::distanceEqual('polyAttr', [[[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [0.0, 0.0]]], 0.0),
                 'distanceNotEqual' => Query::distanceNotEqual('polyAttr', [[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [20.0, 20.0]]], 0.0),
                 'distanceLessThan' => Query::distanceLessThan('polyAttr', [[[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [0.0, 0.0]]], 0.1),
-                'distanceGreaterThan' => Query::distanceGreaterThan('polyAttr', [[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [20.0, 20.0]]], 0.1)
+                'distanceGreaterThan' => Query::distanceGreaterThan('polyAttr', [[[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [20.0, 20.0]]], 0.1),
             ];
 
             foreach ($polyDistanceQueries as $queryType => $query) {
-                $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
+                $result = $database->find($collectionName, [$query], PermissionType::Read);
                 $this->assertNotEmpty($result, sprintf('Failed distance query: %s on polyAttr', $queryType));
                 $this->assertEquals('doc1', $result[0]->getId(), sprintf('Incorrect document for distance %s on polyAttr', $queryType));
             }
@@ -248,21 +221,22 @@ public function testSpatialRelationshipOneToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('location');
-        $database->createCollection('building');
+        $database->createCollection(new Collection(id: 'location'));
+        $database->createCollection(new Collection(id: 'building'));
 
-        $database->createAttribute('location', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('location', 'coordinates', Database::VAR_POINT, 0, true);
-        $database->createAttribute('building', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('building', 'area', Database::VAR_STRING, 255, true);
+        $database->createAttribute('location', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('location', Attribute::point(key: 'coordinates', required: true));
+        $database->createAttribute('building', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('building', Attribute::string(key: 'area', required: true));
 
         // Create spatial indexes
-        $database->createIndex('location', 'coordinates_spatial', Database::INDEX_SPATIAL, ['coordinates']);
+        $database->createIndex('location', Index::spatial(key: 'coordinates_spatial', attributes: ['coordinates']));
 
         // Create building document first
         $building1 = $database->createDocument('building', new Document([
@@ -276,13 +250,7 @@ public function testSpatialRelationshipOneToOne(): void
             'area' => 'Manhattan',
         ]));
 
-        $database->createRelationship(
-            collection: 'location',
-            relatedCollection: 'building',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'building',
-            twoWay: false
-        );
+        $database->createRelationship(Relationship::oneToOne(collection: 'location', relatedCollection: 'building', key: 'building'));
 
         // Create location with spatial data and relationship
         $location1 = $database->createDocument('location', new Document([
@@ -297,7 +265,6 @@ public function testSpatialRelationshipOneToOne(): void
             'building' => 'building1',
         ]));
 
-        $this->assertInstanceOf(Document::class, $location1);
         $this->assertEquals([40.7128, -74.0060], $location1->getAttribute('coordinates'));
 
         // Check if building attribute is populated (could be ID string or Document object)
@@ -311,8 +278,8 @@ public function testSpatialRelationshipOneToOne(): void
 
         // Test spatial queries on related documents
         $nearbyLocations = $database->find('location', [
-            Query::distanceLessThan('coordinates', [40.7128, -74.0060], 0.1)
-        ], Database::PERMISSION_READ);
+            Query::distanceLessThan('coordinates', [40.7128, -74.0060], 0.1),
+        ], PermissionType::Read);
 
         $this->assertNotEmpty($nearbyLocations);
         $this->assertEquals('location1', $nearbyLocations[0]->getId());
@@ -325,22 +292,20 @@ public function testSpatialRelationshipOneToOne(): void
 
         // Test spatial query after update
         $timesSquareLocations = $database->find('location', [
-            Query::distanceLessThan('coordinates', [40.7589, -73.9851], 0.1)
-        ], Database::PERMISSION_READ);
+            Query::distanceLessThan('coordinates', [40.7589, -73.9851], 0.1),
+        ], PermissionType::Read);
 
         $this->assertNotEmpty($timesSquareLocations);
         $this->assertEquals('location1', $timesSquareLocations[0]->getId());
 
         // Test relationship integrity with spatial data
         $building = $database->getDocument('building', 'building1');
-        $this->assertInstanceOf(Document::class, $building);
         $this->assertEquals('building1', $building->getId());
 
         // Test one-way relationship (building doesn't have location attribute)
         $this->assertArrayNotHasKey('location', $building->getArrayCopy());
 
         // Test basic relationship integrity
-        $this->assertInstanceOf(Document::class, $building);
         $this->assertEquals('Empire State Building', $building->getAttribute('name'));
 
         // Clean up
@@ -352,35 +317,34 @@ public function testSpatialAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'spatial_attrs_';
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
-            $required = $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true;
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'pointAttr', Database::VAR_POINT, 0, $required));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'lineAttr', Database::VAR_LINESTRING, 0, $required));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'polyAttr', Database::VAR_POLYGON, 0, $required));
+            $required = $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true;
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'pointAttr', required: $required)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::linestring(key: 'lineAttr', required: $required)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'polyAttr', required: $required)));
 
             // Create spatial indexes
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_point', Database::INDEX_SPATIAL, ['pointAttr']));
-            if ($database->getAdapter()->getSupportForSpatialIndexNull()) {
-                $this->assertEquals(true, $database->createIndex($collectionName, 'idx_line', Database::INDEX_SPATIAL, ['lineAttr']));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_point', attributes: ['pointAttr'])));
+            if ($database->getAdapter()->supports(Capability::SpatialIndexNull)) {
+                $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_line', attributes: ['lineAttr'])));
             } else {
                 // Attribute was created as required above; directly create index once
-                $this->assertEquals(true, $database->createIndex($collectionName, 'idx_line', Database::INDEX_SPATIAL, ['lineAttr']));
+                $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_line', attributes: ['lineAttr'])));
             }
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_poly', Database::INDEX_SPATIAL, ['polyAttr']));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_poly', attributes: ['polyAttr'])));
 
             $collection = $database->getCollection($collectionName);
-            $this->assertIsArray($collection->getAttribute('attributes'));
-            $this->assertCount(3, $collection->getAttribute('attributes'));
-            $this->assertIsArray($collection->getAttribute('indexes'));
-            $this->assertCount(3, $collection->getAttribute('indexes'));
+            $this->assertCount(3, $collection->attributes);
+            $this->assertCount(3, $collection->indexes);
 
             // Create a simple document to ensure structure is valid
             $doc = $database->createDocument($collectionName, new Document([
@@ -388,9 +352,8 @@ public function testSpatialAttributes(): void
                 'pointAttr' => [1.0, 1.0],
                 'lineAttr' => [[0.0, 0.0], [1.0, 1.0]],
                 'polyAttr' => [[[0.0, 0.0], [0.0, 2.0], [2.0, 2.0], [0.0, 0.0]]],
-                '$permissions' => [Permission::read(Role::any())]
+                '$permissions' => [Permission::read(Role::any())],
             ]));
-            $this->assertInstanceOf(Document::class, $doc);
         } finally {
             $database->deleteCollection($collectionName);
         }
@@ -400,108 +363,103 @@ public function testSpatialOneToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parent = 'regions_';
         $child = 'places_';
         try {
-            $database->createCollection($parent);
-            $database->createCollection($child);
+            $database->createCollection(new Collection(id: $parent));
+            $database->createCollection(new Collection(id: $child));
 
-            $database->createAttribute($parent, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($child, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($child, 'coord', Database::VAR_POINT, 0, true);
-            $database->createIndex($child, 'coord_spatial', Database::INDEX_SPATIAL, ['coord']);
+            $database->createAttribute($parent, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($child, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($child, Attribute::point(key: 'coord', required: true));
+            $database->createIndex($child, Index::spatial(key: 'coord_spatial', attributes: ['coord']));
 
-            $database->createRelationship(
+            $database->createRelationship(Relationship::oneToMany(
                 collection: $parent,
                 relatedCollection: $child,
-                type: Database::RELATION_ONE_TO_MANY,
                 twoWay: true,
-                id: 'places',
+                key: 'places',
                 twoWayKey: 'region'
-            );
+            ));
 
-            $r1 = $database->createDocument($parent, new Document([
+            $database->createDocument($parent, new Document([
                 '$id' => 'r1',
                 'name' => 'Region 1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $this->assertInstanceOf(Document::class, $r1);
-
-            $p1 = $database->createDocument($child, new Document([
+            $database->createDocument($child, new Document([
                 '$id' => 'p1',
                 'name' => 'Place 1',
                 'coord' => [10.0, 10.0],
                 'region' => 'r1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $p2 = $database->createDocument($child, new Document([
+            $database->createDocument($child, new Document([
                 '$id' => 'p2',
                 'name' => 'Place 2',
                 'coord' => [10.1, 10.1],
                 'region' => 'r1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $this->assertInstanceOf(Document::class, $p1);
-            $this->assertInstanceOf(Document::class, $p2);
-
             // Spatial query on child collection
             $near = $database->find($child, [
-                Query::distanceLessThan('coord', [10.0, 10.0], 1.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('coord', [10.0, 10.0], 1.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($near);
 
             // Test distanceGreaterThan: places far from center (should find p2 which is 0.141 units away)
             $far = $database->find($child, [
-                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.05)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.05),
+            ], PermissionType::Read);
             $this->assertNotEmpty($far);
 
             // Test distanceLessThan: places very close to center (should find p1 which is exactly at center)
             $close = $database->find($child, [
-                Query::distanceLessThan('coord', [10.0, 10.0], 0.2)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('coord', [10.0, 10.0], 0.2),
+            ], PermissionType::Read);
             $this->assertNotEmpty($close);
 
             // Test distanceGreaterThan with various thresholds
             // Test: places more than 0.12 units from center (should find p2)
             $moderatelyFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.12)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.12),
+            ], PermissionType::Read);
             $this->assertNotEmpty($moderatelyFar);
 
             // Test: places more than 0.05 units from center (should find p2)
             $slightlyFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.05)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [10.0, 10.0], 0.05),
+            ], PermissionType::Read);
             $this->assertNotEmpty($slightlyFar);
 
             // Test: places more than 10 units from center (should find none)
             $extremelyFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [10.0, 10.0], 10.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [10.0, 10.0], 10.0),
+            ], PermissionType::Read);
             $this->assertEmpty($extremelyFar);
 
             // Equal-distanceEqual semantics: distanceEqual (<=) and distanceNotEqual (>), threshold exactly at 0
             $equalZero = $database->find($child, [
-                Query::distanceEqual('coord', [10.0, 10.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('coord', [10.0, 10.0], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($equalZero);
             $this->assertEquals('p1', $equalZero[0]->getId());
 
             $notEqualZero = $database->find($child, [
-                Query::distanceNotEqual('coord', [10.0, 10.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceNotEqual('coord', [10.0, 10.0], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($notEqualZero);
             $this->assertEquals('p2', $notEqualZero[0]->getId());
 
             $region = $database->getDocument($parent, 'r1');
             $this->assertArrayHasKey('places', $region);
-            $this->assertEquals(2, \count($region['places']));
+            $this->assertCount(2, $region->getDocuments('places'));
         } finally {
             $database->deleteCollection($child);
             $database->deleteCollection($parent);
@@ -512,101 +470,97 @@ public function testSpatialManyToOne(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $parent = 'cities_';
         $child = 'stops_';
         try {
-            $database->createCollection($parent);
-            $database->createCollection($child);
+            $database->createCollection(new Collection(id: $parent));
+            $database->createCollection(new Collection(id: $child));
 
-            $database->createAttribute($parent, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($child, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($child, 'coord', Database::VAR_POINT, 0, true);
-            $database->createIndex($child, 'coord_spatial', Database::INDEX_SPATIAL, ['coord']);
+            $database->createAttribute($parent, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($child, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($child, Attribute::point(key: 'coord', required: true));
+            $database->createIndex($child, Index::spatial(key: 'coord_spatial', attributes: ['coord']));
 
-            $database->createRelationship(
+            $database->createRelationship(Relationship::manyToOne(
                 collection: $child,
                 relatedCollection: $parent,
-                type: Database::RELATION_MANY_TO_ONE,
                 twoWay: true,
-                id: 'city',
+                key: 'city',
                 twoWayKey: 'stops'
-            );
+            ));
 
-            $c1 = $database->createDocument($parent, new Document([
+            $database->createDocument($parent, new Document([
                 '$id' => 'c1',
                 'name' => 'City 1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
 
-            $s1 = $database->createDocument($child, new Document([
+            $database->createDocument($child, new Document([
                 '$id' => 's1',
                 'name' => 'Stop 1',
                 'coord' => [20.0, 20.0],
                 'city' => 'c1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $s2 = $database->createDocument($child, new Document([
+            $database->createDocument($child, new Document([
                 '$id' => 's2',
                 'name' => 'Stop 2',
                 'coord' => [20.2, 20.2],
                 'city' => 'c1',
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $this->assertInstanceOf(Document::class, $c1);
-            $this->assertInstanceOf(Document::class, $s1);
-            $this->assertInstanceOf(Document::class, $s2);
-
             $near = $database->find($child, [
-                Query::distanceLessThan('coord', [20.0, 20.0], 1.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('coord', [20.0, 20.0], 1.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($near);
 
             // Test distanceLessThan: stops very close to center (should find s1 which is exactly at center)
             $close = $database->find($child, [
-                Query::distanceLessThan('coord', [20.0, 20.0], 0.1)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('coord', [20.0, 20.0], 0.1),
+            ], PermissionType::Read);
             $this->assertNotEmpty($close);
 
             // Test distanceGreaterThan with various thresholds
             // Test: stops more than 0.25 units from center (should find s2)
             $moderatelyFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [20.0, 20.0], 0.25)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [20.0, 20.0], 0.25),
+            ], PermissionType::Read);
             $this->assertNotEmpty($moderatelyFar);
 
             // Test: stops more than 0.05 units from center (should find s2)
             $slightlyFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [20.0, 20.0], 0.05)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [20.0, 20.0], 0.05),
+            ], PermissionType::Read);
             $this->assertNotEmpty($slightlyFar);
 
             // Test: stops more than 5 units from center (should find none)
             $veryFar = $database->find($child, [
-                Query::distanceGreaterThan('coord', [20.0, 20.0], 5.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('coord', [20.0, 20.0], 5.0),
+            ], PermissionType::Read);
             $this->assertEmpty($veryFar);
 
             // Equal-distanceEqual semantics: distanceEqual (<=) and distanceNotEqual (>), threshold exactly at 0
             $equalZero = $database->find($child, [
-                Query::distanceEqual('coord', [20.0, 20.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('coord', [20.0, 20.0], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($equalZero);
             $this->assertEquals('s1', $equalZero[0]->getId());
 
             $notEqualZero = $database->find($child, [
-                Query::distanceNotEqual('coord', [20.0, 20.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceNotEqual('coord', [20.0, 20.0], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($notEqualZero);
             $this->assertEquals('s2', $notEqualZero[0]->getId());
 
             $city = $database->getDocument($parent, 'c1');
             $this->assertArrayHasKey('stops', $city);
-            $this->assertEquals(2, \count($city['stops']));
+            $this->assertCount(2, $city->getDocuments('stops'));
         } finally {
             $database->deleteCollection($child);
             $database->deleteCollection($parent);
@@ -617,34 +571,34 @@ public function testSpatialManyToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Relationships::class)) || ! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $a = 'drivers_';
         $b = 'routes_';
         try {
-            $database->createCollection($a);
-            $database->createCollection($b);
+            $database->createCollection(new Collection(id: $a));
+            $database->createCollection(new Collection(id: $b));
 
-            $database->createAttribute($a, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($a, 'home', Database::VAR_POINT, 0, true);
-            $database->createIndex($a, 'home_spatial', Database::INDEX_SPATIAL, ['home']);
-            $database->createAttribute($b, 'title', Database::VAR_STRING, 255, true);
-            $database->createAttribute($b, 'area', Database::VAR_POLYGON, 0, true);
-            $database->createIndex($b, 'area_spatial', Database::INDEX_SPATIAL, ['area']);
+            $database->createAttribute($a, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($a, Attribute::point(key: 'home', required: true));
+            $database->createIndex($a, Index::spatial(key: 'home_spatial', attributes: ['home']));
+            $database->createAttribute($b, Attribute::string(key: 'title', required: true));
+            $database->createAttribute($b, Attribute::polygon(key: 'area', required: true));
+            $database->createIndex($b, Index::spatial(key: 'area_spatial', attributes: ['area']));
 
-            $database->createRelationship(
+            $database->createRelationship(Relationship::manyToMany(
                 collection: $a,
                 relatedCollection: $b,
-                type: Database::RELATION_MANY_TO_MANY,
                 twoWay: true,
-                id: 'routes',
+                key: 'routes',
                 twoWayKey: 'drivers'
-            );
+            ));
 
-            $d1 = $database->createDocument($a, new Document([
+            $database->createDocument($a, new Document([
                 '$id' => 'd1',
                 'name' => 'Driver 1',
                 'home' => [30.0, 30.0],
@@ -652,66 +606,64 @@ public function testSpatialManyToMany(): void
                     [
                         '$id' => 'rte1',
                         'title' => 'Route 1',
-                        'area' => [[[29.5,29.5],[29.5,30.5],[30.5,30.5],[29.5,29.5]]]
-                    ]
+                        'area' => [[[29.5, 29.5], [29.5, 30.5], [30.5, 30.5], [29.5, 29.5]]],
+                    ],
                 ],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $this->assertInstanceOf(Document::class, $d1);
-
             // Spatial query on "drivers" using point distanceEqual
             $near = $database->find($a, [
-                Query::distanceLessThan('home', [30.0, 30.0], 0.5)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('home', [30.0, 30.0], 0.5),
+            ], PermissionType::Read);
             $this->assertNotEmpty($near);
 
             // Test distanceGreaterThan: drivers far from center (using large threshold to find the driver)
             $far = $database->find($a, [
-                Query::distanceGreaterThan('home', [30.0, 30.0], 100.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('home', [30.0, 30.0], 100.0),
+            ], PermissionType::Read);
             $this->assertEmpty($far);
 
             // Test distanceLessThan: drivers very close to center (should find d1 which is exactly at center)
             $close = $database->find($a, [
-                Query::distanceLessThan('home', [30.0, 30.0], 0.1)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('home', [30.0, 30.0], 0.1),
+            ], PermissionType::Read);
             $this->assertNotEmpty($close);
 
             // Test distanceGreaterThan with various thresholds
             // Test: drivers more than 0.05 units from center (should find none since d1 is exactly at center)
             $slightlyFar = $database->find($a, [
-                Query::distanceGreaterThan('home', [30.0, 30.0], 0.05)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('home', [30.0, 30.0], 0.05),
+            ], PermissionType::Read);
             $this->assertEmpty($slightlyFar);
 
             // Test: drivers more than 0.001 units from center (should find none since d1 is exactly at center)
             $verySlightlyFar = $database->find($a, [
-                Query::distanceGreaterThan('home', [30.0, 30.0], 0.001)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('home', [30.0, 30.0], 0.001),
+            ], PermissionType::Read);
             $this->assertEmpty($verySlightlyFar);
 
             // Test: drivers more than 0.5 units from center (should find none since d1 is at center)
             $moderatelyFar = $database->find($a, [
-                Query::distanceGreaterThan('home', [30.0, 30.0], 0.5)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('home', [30.0, 30.0], 0.5),
+            ], PermissionType::Read);
             $this->assertEmpty($moderatelyFar);
 
             // Equal-distanceEqual semantics: distanceEqual (<=) and distanceNotEqual (>), threshold exactly at 0
             $equalZero = $database->find($a, [
-                Query::distanceEqual('home', [30.0, 30.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('home', [30.0, 30.0], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($equalZero);
             $this->assertEquals('d1', $equalZero[0]->getId());
 
             $notEqualZero = $database->find($a, [
-                Query::distanceNotEqual('home', [30.0, 30.0], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceNotEqual('home', [30.0, 30.0], 0.0),
+            ], PermissionType::Read);
             $this->assertEmpty($notEqualZero);
 
             // Ensure relationship present
             $d1 = $database->getDocument($a, 'd1');
             $this->assertArrayHasKey('routes', $d1);
-            $this->assertEquals(1, \count($d1['routes']));
+            $this->assertCount(1, $d1->getDocuments('routes'));
         } finally {
             $database->deleteCollection($b);
             $database->deleteCollection($a);
@@ -722,61 +674,57 @@ public function testSpatialIndex(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Basic spatial index create/delete
         $collectionName = 'spatial_index_';
         try {
-            $database->createCollection($collectionName);
-            $database->createAttribute($collectionName, 'loc', Database::VAR_POINT, 0, true);
-            $this->assertEquals(true, $database->createIndex($collectionName, 'loc_spatial', Database::INDEX_SPATIAL, ['loc']));
+            $database->createCollection(new Collection(id: $collectionName));
+            $database->createAttribute($collectionName, Attribute::point(key: 'loc', required: true));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'loc_spatial', attributes: ['loc'])));
 
             $collection = $database->getCollection($collectionName);
-            $this->assertIsArray($collection->getAttribute('indexes'));
-            $this->assertCount(1, $collection->getAttribute('indexes'));
-            $this->assertEquals('loc_spatial', $collection->getAttribute('indexes')[0]['$id']);
-            $this->assertEquals(Database::INDEX_SPATIAL, $collection->getAttribute('indexes')[0]['type']);
+            $indexes = $collection->indexes;
+            $this->assertCount(1, $indexes);
+            $index = $indexes[0] ?? null;
+            $this->assertInstanceOf(Document::class, $index);
+            $this->assertSame('loc_spatial', $index->getId());
+            $this->assertSame(IndexType::Spatial->value, $index->getAttribute('type'));
 
             $this->assertEquals(true, $database->deleteIndex($collectionName, 'loc_spatial'));
             $collection = $database->getCollection($collectionName);
-            $this->assertCount(0, $collection->getAttribute('indexes'));
+            $this->assertCount(0, $collection->indexes);
         } finally {
             $database->deleteCollection($collectionName);
         }
 
         // Edge cases: Spatial Index Order support (createCollection and createIndex)
-        $orderSupported = $database->getAdapter()->getSupportForSpatialIndexOrder();
+        $orderSupported = $database->getAdapter()->supports(Capability::SpatialIndexOrder);
 
         // createCollection with orders
         $collOrderCreate = 'spatial_idx_order_create';
         try {
-            $attributes = [new Document([
-                '$id' => ID::custom('loc'),
-                'type' => Database::VAR_POINT,
-                'size' => 0,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ])];
-            $indexes = [new Document([
-                '$id' => ID::custom('idx_loc'),
-                'type' => Database::INDEX_SPATIAL,
-                'attributes' => ['loc'],
-                'lengths' => [],
-                'orders' => $orderSupported ? [Database::ORDER_ASC] : ['ASC'],
-            ])];
+            $attributes = [Attribute::point(key: 'loc', required: true)];
+            $indexes = [Index::spatial(
+                key: 'idx_loc',
+                attributes: ['loc'],
+                orders: [Order::Asc],
+            )];
 
             if ($orderSupported) {
-                $database->createCollection($collOrderCreate, $attributes, $indexes);
+                $database->createCollection(new Collection(id: $collOrderCreate, attributes: $attributes, indexes: $indexes));
                 $meta = $database->getCollection($collOrderCreate);
-                $this->assertEquals('idx_loc', $meta->getAttribute('indexes')[0]['$id']);
+                $createdIndexes = $meta->indexes;
+                $createdIndex = $createdIndexes[0] ?? null;
+                $this->assertInstanceOf(Document::class, $createdIndex);
+                $this->assertSame('idx_loc', $createdIndex->getId());
             } else {
                 try {
-                    $database->createCollection($collOrderCreate, $attributes, $indexes);
+                    $database->createCollection(new Collection(id: $collOrderCreate, attributes: $attributes, indexes: $indexes));
                     $this->fail('Expected exception when orders are provided for spatial index on unsupported adapter');
                 } catch (\Throwable $e) {
                     $this->assertStringContainsString('Spatial index', $e->getMessage());
@@ -789,15 +737,15 @@ public function testSpatialIndex(): void
         }
 
         // createIndex with orders
-        $collOrderIndex = 'spatial_idx_order_index_' . uniqid();
+        $collOrderIndex = 'spatial_idx_order_index_'.uniqid();
         try {
-            $database->createCollection($collOrderIndex);
-            $database->createAttribute($collOrderIndex, 'loc', Database::VAR_POINT, 0, true);
+            $database->createCollection(new Collection(id: $collOrderIndex));
+            $database->createAttribute($collOrderIndex, Attribute::point(key: 'loc', required: true));
             if ($orderSupported) {
-                $this->assertTrue($database->createIndex($collOrderIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc'], [], [Database::ORDER_DESC]));
+                $this->assertTrue($database->createIndex($collOrderIndex, Index::spatial(key: 'idx_loc', attributes: ['loc'], orders: [Order::Desc])));
             } else {
                 try {
-                    $database->createIndex($collOrderIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc'], [], ['DESC']);
+                    $database->createIndex($collOrderIndex, Index::spatial(key: 'idx_loc', attributes: ['loc'], orders: [Order::Desc]));
                     $this->fail('Expected exception when orders are provided for spatial index on unsupported adapter');
                 } catch (\Throwable $e) {
                     $this->assertStringContainsString('Spatial index', $e->getMessage());
@@ -808,38 +756,27 @@ public function testSpatialIndex(): void
         }
 
         // Edge cases: Spatial Index Nullability (createCollection and createIndex)
-        $nullSupported = $database->getAdapter()->getSupportForSpatialIndexNull();
+        $nullSupported = $database->getAdapter()->supports(Capability::SpatialIndexNull);
 
         // createCollection with required=false
-        $collNullCreate = 'spatial_idx_null_create_' . uniqid();
+        $collNullCreate = 'spatial_idx_null_create_'.uniqid();
         try {
-            $attributes = [new Document([
-                '$id' => ID::custom('loc'),
-                'type' => Database::VAR_POINT,
-                'size' => 0,
-                'required' => false, // edge case
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ])];
-            $indexes = [new Document([
-                '$id' => ID::custom('idx_loc'),
-                'type' => Database::INDEX_SPATIAL,
-                'attributes' => ['loc'],
-                'lengths' => [],
-                'orders' => [],
-            ])];
+            $attributes = [Attribute::point(key: 'loc')];
+            $indexes = [Index::spatial(key: 'idx_loc', attributes: ['loc'])];
 
             if ($nullSupported) {
-                $database->createCollection($collNullCreate, $attributes, $indexes);
+                $database->createCollection(new Collection(id: $collNullCreate, attributes: $attributes, indexes: $indexes));
                 $meta = $database->getCollection($collNullCreate);
-                $this->assertEquals('idx_loc', $meta->getAttribute('indexes')[0]['$id']);
+                $createdIndexes = $meta->indexes;
+                $createdIndex = $createdIndexes[0] ?? null;
+                $this->assertInstanceOf(Document::class, $createdIndex);
+                $this->assertSame('idx_loc', $createdIndex->getId());
             } else {
                 try {
-                    $database->createCollection($collNullCreate, $attributes, $indexes);
+                    $database->createCollection(new Collection(id: $collNullCreate, attributes: $attributes, indexes: $indexes));
                     $this->fail('Expected exception when spatial index is created on NULL-able geometry attribute');
                 } catch (\Throwable $e) {
-                    $this->assertTrue(true); // exception expected; exact message is adapter-specific
+                    $this->assertNotSame('', $e->getMessage());
                 }
             }
         } finally {
@@ -849,18 +786,18 @@ public function testSpatialIndex(): void
         }
 
         // createIndex with required=false
-        $collNullIndex = 'spatial_idx_null_index_' . uniqid();
+        $collNullIndex = 'spatial_idx_null_index_'.uniqid();
         try {
-            $database->createCollection($collNullIndex);
-            $database->createAttribute($collNullIndex, 'loc', Database::VAR_POINT, 0, false);
+            $database->createCollection(new Collection(id: $collNullIndex));
+            $database->createAttribute($collNullIndex, Attribute::point(key: 'loc'));
             if ($nullSupported) {
-                $this->assertTrue($database->createIndex($collNullIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
+                $this->assertTrue($database->createIndex($collNullIndex, Index::spatial(key: 'idx_loc', attributes: ['loc'])));
             } else {
                 try {
-                    $database->createIndex($collNullIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collNullIndex, Index::spatial(key: 'idx_loc', attributes: ['loc']));
                     $this->fail('Expected exception when spatial index is created on NULL-able geometry attribute');
                 } catch (\Throwable $e) {
-                    $this->assertTrue(true); // exception expected; exact message is adapter-specific
+                    $this->assertNotSame('', $e->getMessage()); // exception expected; exact message is adapter-specific
                 }
             }
         } finally {
@@ -869,47 +806,46 @@ public function testSpatialIndex(): void
 
         $collUpdateNull = 'spatial_idx_req';
         try {
-            $database->createCollection($collUpdateNull);
+            $database->createCollection(new Collection(id: $collUpdateNull));
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
-            if (!$nullSupported) {
+            $database->createAttribute($collUpdateNull, Attribute::point(key: 'loc'));
+            if (! $nullSupported) {
                 try {
-                    $database->createIndex($collUpdateNull, 'idx_loc_required', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc_required', attributes: ['loc']));
                     $this->fail('Expected exception when creating spatial index on NULL-able attribute');
                 } catch (\Throwable $e) {
                     $this->assertInstanceOf(Exception::class, $e);
                 }
             } else {
-                $this->assertTrue($database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
+                $this->assertTrue($database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc', attributes: ['loc'])));
             }
 
             $database->updateAttribute($collUpdateNull, 'loc', required: true);
 
-            $this->assertTrue($database->createIndex($collUpdateNull, 'idx_loc_req', Database::INDEX_SPATIAL, ['loc']));
+            $this->assertTrue($database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc_req', attributes: ['loc'])));
         } finally {
             $database->deleteCollection($collUpdateNull);
         }
 
-
         $collUpdateNull = 'spatial_idx_index_null_required_true';
         try {
-            $database->createCollection($collUpdateNull);
+            $database->createCollection(new Collection(id: $collUpdateNull));
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
-            if (!$nullSupported) {
+            $database->createAttribute($collUpdateNull, Attribute::point(key: 'loc'));
+            if (! $nullSupported) {
                 try {
-                    $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc', attributes: ['loc']));
                     $this->fail('Expected exception when creating spatial index on NULL-able attribute');
                 } catch (\Throwable $e) {
                     $this->assertInstanceOf(Exception::class, $e);
                 }
             } else {
-                $this->assertTrue($database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
+                $this->assertTrue($database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc', attributes: ['loc'])));
             }
 
             $database->updateAttribute($collUpdateNull, 'loc', required: true);
 
-            $this->assertTrue($database->createIndex($collUpdateNull, 'new index', Database::INDEX_SPATIAL, ['loc']));
+            $this->assertTrue($database->createIndex($collUpdateNull, Index::spatial(key: 'new index', attributes: ['loc'])));
         } finally {
             $database->deleteCollection($collUpdateNull);
         }
@@ -919,30 +855,31 @@ public function testComplexGeometricShapes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'complex_shapes_';
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
             // Create spatial attributes for different geometric shapes
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'rectangle', Database::VAR_POLYGON, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'square', Database::VAR_POLYGON, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'triangle', Database::VAR_POLYGON, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'circle_center', Database::VAR_POINT, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'complex_polygon', Database::VAR_POLYGON, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'multi_linestring', Database::VAR_LINESTRING, 0, true));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'rectangle', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'square', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'triangle', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'circle_center', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'complex_polygon', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::linestring(key: 'multi_linestring', required: true)));
 
             // Create spatial indexes
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_rectangle', Database::INDEX_SPATIAL, ['rectangle']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_square', Database::INDEX_SPATIAL, ['square']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_triangle', Database::INDEX_SPATIAL, ['triangle']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_circle_center', Database::INDEX_SPATIAL, ['circle_center']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_complex_polygon', Database::INDEX_SPATIAL, ['complex_polygon']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_multi_linestring', Database::INDEX_SPATIAL, ['multi_linestring']));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_rectangle', attributes: ['rectangle'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_square', attributes: ['square'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_triangle', attributes: ['triangle'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_circle_center', attributes: ['circle_center'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_complex_polygon', attributes: ['complex_polygon'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_multi_linestring', attributes: ['multi_linestring'])));
 
             // Create documents with different geometric shapes
             $doc1 = new Document([
@@ -953,7 +890,7 @@ public function testComplexGeometricShapes(): void
                 'circle_center' => [10, 5], // center of rectangle
                 'complex_polygon' => [[[0, 0], [0, 20], [20, 20], [20, 15], [15, 15], [15, 5], [20, 5], [20, 0], [0, 0]]], // L-shaped polygon
                 'multi_linestring' => [[0, 0], [10, 10], [20, 0], [0, 20], [20, 20]], // single linestring with multiple points
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]);
 
             $doc2 = new Document([
@@ -964,45 +901,42 @@ public function testComplexGeometricShapes(): void
                 'circle_center' => [40, 4], // center of second rectangle
                 'complex_polygon' => [[[30, 0], [30, 20], [50, 20], [50, 10], [40, 10], [40, 0], [30, 0]]], // T-shaped polygon
                 'multi_linestring' => [[30, 0], [40, 10], [50, 0], [30, 20], [50, 20]], // single linestring with multiple points
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]);
 
-            $createdDoc1 = $database->createDocument($collectionName, $doc1);
-            $createdDoc2 = $database->createDocument($collectionName, $doc2);
-
-            $this->assertInstanceOf(Document::class, $createdDoc1);
-            $this->assertInstanceOf(Document::class, $createdDoc2);
+            $database->createDocument($collectionName, $doc1);
+            $database->createDocument($collectionName, $doc2);
 
             // Test rectangle contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $insideRect1 = $database->find($collectionName, [
-                    Query::contains('rectangle', [[5, 5]]) // Point inside first rectangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('rectangle', [[5, 5]]), // Point inside first rectangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($insideRect1);
                 $this->assertEquals('rect1', $insideRect1[0]->getId());
             }
 
             // Test rectangle doesn't contain point outside
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsideRect1 = $database->find($collectionName, [
-                    Query::notContains('rectangle', [[25, 25]]) // Point outside first rectangle
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('rectangle', [[25, 25]]), // Point outside first rectangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($outsideRect1);
             }
 
             // Test failure case: rectangle should NOT contain distant point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $distantPoint = $database->find($collectionName, [
-                    Query::contains('rectangle', [[100, 100]]) // Point far outside rectangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('rectangle', [[100, 100]]), // Point far outside rectangle
+                ], PermissionType::Read);
                 $this->assertEmpty($distantPoint);
             }
 
             // Test failure case: rectangle should NOT contain point outside
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsidePoint = $database->find($collectionName, [
-                    Query::contains('rectangle', [[-1, -1]]) // Point clearly outside rectangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('rectangle', [[-1, -1]]), // Point clearly outside rectangle
+                ], PermissionType::Read);
                 $this->assertEmpty($outsidePoint);
             }
 
@@ -1010,334 +944,333 @@ public function testComplexGeometricShapes(): void
             $overlappingRect = $database->find($collectionName, [
                 Query::and([
                     Query::intersects('rectangle', [[15, 5], [15, 15], [25, 15], [25, 5], [15, 5]]),
-                    Query::notTouches('rectangle', [[15, 5], [15, 15], [25, 15], [25, 5], [15, 5]])
+                    Query::notTouches('rectangle', [[15, 5], [15, 15], [25, 15], [25, 5], [15, 5]]),
                 ]),
-            ], Database::PERMISSION_READ);
+            ], PermissionType::Read);
             $this->assertNotEmpty($overlappingRect);
 
-
             // Test square contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $insideSquare1 = $database->find($collectionName, [
-                    Query::contains('square', [[10, 10]]) // Point inside first square
-                ], Database::PERMISSION_READ);
+                    Query::covers('square', [[10, 10]]), // Point inside first square
+                ], PermissionType::Read);
                 $this->assertNotEmpty($insideSquare1);
                 $this->assertEquals('rect1', $insideSquare1[0]->getId());
             }
 
             // Test rectangle contains square (shape contains shape)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $rectContainsSquare = $database->find($collectionName, [
-                    Query::contains('rectangle', [[[5, 2], [5, 8], [15, 8], [15, 2], [5, 2]]]) // Square geometry that fits within rectangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('rectangle', [[[5, 2], [5, 8], [15, 8], [15, 2], [5, 2]]]), // Square geometry that fits within rectangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($rectContainsSquare);
                 $this->assertEquals('rect1', $rectContainsSquare[0]->getId());
             }
 
             // Test rectangle contains triangle (shape contains shape)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $rectContainsTriangle = $database->find($collectionName, [
-                    Query::contains('rectangle', [[[10, 2], [18, 2], [14, 8], [10, 2]]]) // Triangle geometry that fits within rectangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('rectangle', [[[10, 2], [18, 2], [14, 8], [10, 2]]]), // Triangle geometry that fits within rectangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($rectContainsTriangle);
                 $this->assertEquals('rect1', $rectContainsTriangle[0]->getId());
             }
 
             // Test L-shaped polygon contains smaller rectangle (shape contains shape)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $lShapeContainsRect = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[[5, 5], [5, 10], [10, 10], [10, 5], [5, 5]]]) // Small rectangle inside L-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[[5, 5], [5, 10], [10, 10], [10, 5], [5, 5]]]), // Small rectangle inside L-shape
+                ], PermissionType::Read);
                 $this->assertNotEmpty($lShapeContainsRect);
                 $this->assertEquals('rect1', $lShapeContainsRect[0]->getId());
             }
 
             // Test T-shaped polygon contains smaller square (shape contains shape)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $tShapeContainsSquare = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[[35, 5], [35, 10], [40, 10], [40, 5], [35, 5]]]) // Small square inside T-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[[35, 5], [35, 10], [40, 10], [40, 5], [35, 5]]]), // Small square inside T-shape
+                ], PermissionType::Read);
                 $this->assertNotEmpty($tShapeContainsSquare);
                 $this->assertEquals('rect2', $tShapeContainsSquare[0]->getId());
             }
 
             // Test failure case: square should NOT contain rectangle (smaller shape cannot contain larger shape)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $squareNotContainsRect = $database->find($collectionName, [
-                    Query::notContains('square', [[[0, 0], [0, 20], [20, 20], [20, 0], [0, 0]]]) // Larger rectangle
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('square', [[[0, 0], [0, 20], [20, 20], [20, 0], [0, 0]]]), // Larger rectangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($squareNotContainsRect);
             }
 
             // Test failure case: triangle should NOT contain rectangle
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $triangleNotContainsRect = $database->find($collectionName, [
-                    Query::notContains('triangle', [[[20, 0], [20, 25], [30, 25], [30, 0], [20, 0]]]) // Rectangle that extends beyond triangle
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('triangle', [[[20, 0], [20, 25], [30, 25], [30, 0], [20, 0]]]), // Rectangle that extends beyond triangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($triangleNotContainsRect);
             }
 
             // Test failure case: L-shape should NOT contain T-shape (different complex polygons)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $lShapeNotContainsTShape = $database->find($collectionName, [
-                    Query::notContains('complex_polygon', [[[30, 0], [30, 20], [50, 20], [50, 0], [30, 0]]]) // T-shape geometry
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('complex_polygon', [[[30, 0], [30, 20], [50, 20], [50, 0], [30, 0]]]), // T-shape geometry
+                ], PermissionType::Read);
                 $this->assertNotEmpty($lShapeNotContainsTShape);
             }
 
             // Test square doesn't contain point outside
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsideSquare1 = $database->find($collectionName, [
-                    Query::notContains('square', [[20, 20]]) // Point outside first square
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('square', [[20, 20]]), // Point outside first square
+                ], PermissionType::Read);
                 $this->assertNotEmpty($outsideSquare1);
             }
 
             // Test failure case: square should NOT contain distant point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $distantPointSquare = $database->find($collectionName, [
-                    Query::contains('square', [[100, 100]]) // Point far outside square
-                ], Database::PERMISSION_READ);
+                    Query::covers('square', [[100, 100]]), // Point far outside square
+                ], PermissionType::Read);
                 $this->assertEmpty($distantPointSquare);
             }
 
             // Test failure case: square should NOT contain point on boundary
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $boundaryPointSquare = $database->find($collectionName, [
-                    Query::contains('square', [[5, 5]]) // Point on square boundary (should be empty if boundary not inclusive)
-                ], Database::PERMISSION_READ);
+                    Query::covers('square', [[5, 5]]), // Point on square boundary (should be empty if boundary not inclusive)
+                ], PermissionType::Read);
                 // Note: This may or may not be empty depending on boundary inclusivity
             }
 
             // Test square equals same geometry using contains when supported, otherwise intersects
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $exactSquare = $database->find($collectionName, [
-                    Query::contains('square', [[[5, 5], [5, 15], [15, 15], [15, 5], [5, 5]]])
-                ], Database::PERMISSION_READ);
+                    Query::covers('square', [[[5, 5], [5, 15], [15, 15], [15, 5], [5, 5]]]),
+                ], PermissionType::Read);
             } else {
                 $exactSquare = $database->find($collectionName, [
-                    Query::intersects('square', [[5, 5], [5, 15], [15, 15], [15, 5], [5, 5]])
-                ], Database::PERMISSION_READ);
+                    Query::intersects('square', [[5, 5], [5, 15], [15, 15], [15, 5], [5, 5]]),
+                ], PermissionType::Read);
             }
             $this->assertNotEmpty($exactSquare);
             $this->assertEquals('rect1', $exactSquare[0]->getId());
 
             // Test square doesn't equal different square
             $differentSquare = $database->find($collectionName, [
-                query::notEqual('square', [[[0, 0], [0, 10], [10, 10], [10, 0], [0, 0]]]) // Different square
-            ], Database::PERMISSION_READ);
+                query::notEqual('square', [[[0, 0], [0, 10], [10, 10], [10, 0], [0, 0]]]), // Different square
+            ], PermissionType::Read);
             $this->assertNotEmpty($differentSquare);
 
             // Test triangle contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $insideTriangle1 = $database->find($collectionName, [
-                    Query::contains('triangle', [[25, 10]]) // Point inside first triangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('triangle', [[25, 10]]), // Point inside first triangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($insideTriangle1);
                 $this->assertEquals('rect1', $insideTriangle1[0]->getId());
             }
 
             // Test triangle doesn't contain point outside
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsideTriangle1 = $database->find($collectionName, [
-                    Query::notContains('triangle', [[25, 25]]) // Point outside first triangle
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('triangle', [[25, 25]]), // Point outside first triangle
+                ], PermissionType::Read);
                 $this->assertNotEmpty($outsideTriangle1);
             }
 
             // Test failure case: triangle should NOT contain distant point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $distantPointTriangle = $database->find($collectionName, [
-                    Query::contains('triangle', [[100, 100]]) // Point far outside triangle
-                ], Database::PERMISSION_READ);
+                    Query::covers('triangle', [[100, 100]]), // Point far outside triangle
+                ], PermissionType::Read);
                 $this->assertEmpty($distantPointTriangle);
             }
 
             // Test failure case: triangle should NOT contain point outside its area
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsideTriangleArea = $database->find($collectionName, [
-                    Query::contains('triangle', [[35, 25]]) // Point outside triangle area
-                ], Database::PERMISSION_READ);
+                    Query::covers('triangle', [[35, 25]]), // Point outside triangle area
+                ], PermissionType::Read);
                 $this->assertEmpty($outsideTriangleArea);
             }
 
             // Test triangle intersects with point
             $intersectingTriangle = $database->find($collectionName, [
-                Query::intersects('triangle', [25, 10]) // Point inside triangle should intersect
-            ], Database::PERMISSION_READ);
+                Query::intersects('triangle', [25, 10]), // Point inside triangle should intersect
+            ], PermissionType::Read);
             $this->assertNotEmpty($intersectingTriangle);
 
             // Test triangle doesn't intersect with distant point
             $nonIntersectingTriangle = $database->find($collectionName, [
-                Query::notIntersects('triangle', [10, 10]) // Distant point should not intersect
-            ], Database::PERMISSION_READ);
+                Query::notIntersects('triangle', [10, 10]), // Distant point should not intersect
+            ], PermissionType::Read);
             $this->assertNotEmpty($nonIntersectingTriangle);
 
             // Test L-shaped polygon contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $insideLShape = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[10, 10]]) // Point inside L-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[10, 10]]), // Point inside L-shape
+                ], PermissionType::Read);
                 $this->assertNotEmpty($insideLShape);
                 $this->assertEquals('rect1', $insideLShape[0]->getId());
             }
 
             // Test L-shaped polygon doesn't contain point in "hole"
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $inHole = $database->find($collectionName, [
-                    Query::notContains('complex_polygon', [[17, 10]]) // Point in the "hole" of L-shape
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('complex_polygon', [[17, 10]]), // Point in the "hole" of L-shape
+                ], PermissionType::Read);
                 $this->assertNotEmpty($inHole);
             }
 
             // Test failure case: L-shaped polygon should NOT contain distant point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $distantPointLShape = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[100, 100]]) // Point far outside L-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[100, 100]]), // Point far outside L-shape
+                ], PermissionType::Read);
                 $this->assertEmpty($distantPointLShape);
             }
 
             // Test failure case: L-shaped polygon should NOT contain point in the hole
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $holePoint = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[17, 10]]) // Point in the "hole" of L-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[17, 10]]), // Point in the "hole" of L-shape
+                ], PermissionType::Read);
                 $this->assertEmpty($holePoint);
             }
 
             // Test T-shaped polygon contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $insideTShape = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[40, 5]]) // Point inside T-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[40, 5]]), // Point inside T-shape
+                ], PermissionType::Read);
                 $this->assertNotEmpty($insideTShape);
                 $this->assertEquals('rect2', $insideTShape[0]->getId());
             }
 
             // Test failure case: T-shaped polygon should NOT contain distant point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $distantPointTShape = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[100, 100]]) // Point far outside T-shape
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[100, 100]]), // Point far outside T-shape
+                ], PermissionType::Read);
                 $this->assertEmpty($distantPointTShape);
             }
 
             // Test failure case: T-shaped polygon should NOT contain point outside its area
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $outsideTShapeArea = $database->find($collectionName, [
-                    Query::contains('complex_polygon', [[25, 25]]) // Point outside T-shape area
-                ], Database::PERMISSION_READ);
+                    Query::covers('complex_polygon', [[25, 25]]), // Point outside T-shape area
+                ], PermissionType::Read);
                 $this->assertEmpty($outsideTShapeArea);
             }
 
             // Test complex polygon intersects with line
             $intersectingLine = $database->find($collectionName, [
-                Query::intersects('complex_polygon', [[0, 10], [20, 10]]) // Horizontal line through L-shape
-            ], Database::PERMISSION_READ);
+                Query::intersects('complex_polygon', [[0, 10], [20, 10]]), // Horizontal line through L-shape
+            ], PermissionType::Read);
             $this->assertNotEmpty($intersectingLine);
 
             // Test linestring contains point
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $onLine1 = $database->find($collectionName, [
-                    Query::contains('multi_linestring', [[5, 5]]) // Point on first line segment
-                ], Database::PERMISSION_READ);
+                    Query::covers('multi_linestring', [[5, 5]]), // Point on first line segment
+                ], PermissionType::Read);
                 $this->assertNotEmpty($onLine1);
             }
 
             // Test linestring doesn't contain point off line
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $offLine1 = $database->find($collectionName, [
-                    Query::notContains('multi_linestring', [[5, 15]]) // Point not on any line
-                ], Database::PERMISSION_READ);
+                    Query::notCovers('multi_linestring', [[5, 15]]), // Point not on any line
+                ], PermissionType::Read);
                 $this->assertNotEmpty($offLine1);
             }
 
             // Test linestring intersects with point
             $intersectingPoint = $database->find($collectionName, [
-                Query::intersects('multi_linestring', [10, 10]) // Point on diagonal line
-            ], Database::PERMISSION_READ);
+                Query::intersects('multi_linestring', [10, 10]), // Point on diagonal line
+            ], PermissionType::Read);
             $this->assertNotEmpty($intersectingPoint);
 
             // Test linestring intersects with a horizontal line coincident at y=20
             $touchingLine = $database->find($collectionName, [
-                Query::intersects('multi_linestring', [[0, 20], [20, 20]])
-            ], Database::PERMISSION_READ);
+                Query::intersects('multi_linestring', [[0, 20], [20, 20]]),
+            ], PermissionType::Read);
             $this->assertNotEmpty($touchingLine);
 
             // Test distanceEqual queries between shapes
             $nearCenter = $database->find($collectionName, [
-                Query::distanceLessThan('circle_center', [10, 5], 5.0) // Points within 5 units of first center
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('circle_center', [10, 5], 5.0), // Points within 5 units of first center
+            ], PermissionType::Read);
             $this->assertNotEmpty($nearCenter);
             $this->assertEquals('rect1', $nearCenter[0]->getId());
 
             // Test distanceEqual queries to find nearby shapes
             $nearbyShapes = $database->find($collectionName, [
-                Query::distanceLessThan('circle_center', [40, 4], 15.0) // Points within 15 units of second center
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('circle_center', [40, 4], 15.0), // Points within 15 units of second center
+            ], PermissionType::Read);
             $this->assertNotEmpty($nearbyShapes);
             $this->assertEquals('rect2', $nearbyShapes[0]->getId());
 
             // Test distanceGreaterThan queries
             $farShapes = $database->find($collectionName, [
-                Query::distanceGreaterThan('circle_center', [10, 5], 10.0) // Points more than 10 units from first center
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('circle_center', [10, 5], 10.0), // Points more than 10 units from first center
+            ], PermissionType::Read);
             $this->assertNotEmpty($farShapes);
             $this->assertEquals('rect2', $farShapes[0]->getId());
 
             // Test distanceLessThan queries
             $closeShapes = $database->find($collectionName, [
-                Query::distanceLessThan('circle_center', [10, 5], 3.0) // Points less than 3 units from first center
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('circle_center', [10, 5], 3.0), // Points less than 3 units from first center
+            ], PermissionType::Read);
             $this->assertNotEmpty($closeShapes);
             $this->assertEquals('rect1', $closeShapes[0]->getId());
 
             // Test distanceGreaterThan queries with various thresholds
             // Test: points more than 20 units from first center (should find rect2)
             $veryFarShapes = $database->find($collectionName, [
-                Query::distanceGreaterThan('circle_center', [10, 5], 20.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('circle_center', [10, 5], 20.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($veryFarShapes);
             $this->assertEquals('rect2', $veryFarShapes[0]->getId());
 
             // Test: points more than 5 units from second center (should find rect1)
             $farFromSecondCenter = $database->find($collectionName, [
-                Query::distanceGreaterThan('circle_center', [40, 4], 5.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('circle_center', [40, 4], 5.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($farFromSecondCenter);
             $this->assertEquals('rect1', $farFromSecondCenter[0]->getId());
 
             // Test: points more than 30 units from origin (should find only rect2)
             $farFromOrigin = $database->find($collectionName, [
-                Query::distanceGreaterThan('circle_center', [0, 0], 30.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('circle_center', [0, 0], 30.0),
+            ], PermissionType::Read);
             $this->assertCount(1, $farFromOrigin);
 
             // Equal-distanceEqual semantics for circle_center
             // rect1 is exactly at [10,5], so distanceEqual 0
             $equalZero = $database->find($collectionName, [
-                Query::distanceEqual('circle_center', [10, 5], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('circle_center', [10, 5], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($equalZero);
             $this->assertEquals('rect1', $equalZero[0]->getId());
 
             $notEqualZero = $database->find($collectionName, [
-                Query::distanceNotEqual('circle_center', [10, 5], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceNotEqual('circle_center', [10, 5], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($notEqualZero);
             $this->assertEquals('rect2', $notEqualZero[0]->getId());
 
             // Additional distance queries for complex shapes (polygon and linestring)
             $rectDistanceEqual = $database->find($collectionName, [
-                Query::distanceEqual('rectangle', [[[0, 0], [0, 10], [20, 10], [20, 0], [0, 0]]], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('rectangle', [[[0, 0], [0, 10], [20, 10], [20, 0], [0, 0]]], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($rectDistanceEqual);
             $this->assertEquals('rect1', $rectDistanceEqual[0]->getId());
 
             $lineDistanceEqual = $database->find($collectionName, [
-                Query::distanceEqual('multi_linestring', [[0, 0], [10, 10], [20, 0], [0, 20], [20, 20]], 0.0)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('multi_linestring', [[0, 0], [10, 10], [20, 0], [0, 20], [20, 20]], 0.0),
+            ], PermissionType::Read);
             $this->assertNotEmpty($lineDistanceEqual);
             $this->assertEquals('rect1', $lineDistanceEqual[0]->getId());
 
@@ -1350,25 +1283,26 @@ public function testSpatialQueryCombinations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'spatial_combinations_';
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
             // Create spatial attributes
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'location', Database::VAR_POINT, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'area', Database::VAR_POLYGON, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'route', Database::VAR_LINESTRING, 0, true));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'name', Database::VAR_STRING, 255, true));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'location', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::polygon(key: 'area', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::linestring(key: 'route', required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::string(key: 'name', required: true)));
 
             // Create spatial indexes
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_location', Database::INDEX_SPATIAL, ['location']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_area', Database::INDEX_SPATIAL, ['area']));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_route', Database::INDEX_SPATIAL, ['route']));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_location', attributes: ['location'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_area', attributes: ['area'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_route', attributes: ['route'])));
 
             // Create test documents
             $doc1 = new Document([
@@ -1377,7 +1311,7 @@ public function testSpatialQueryCombinations(): void
                 'location' => [40.7829, -73.9654],
                 'area' => [[[40.7649, -73.9814], [40.7649, -73.9494], [40.8009, -73.9494], [40.8009, -73.9814], [40.7649, -73.9814]]],
                 'route' => [[40.7649, -73.9814], [40.8009, -73.9494]],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]);
 
             $doc2 = new Document([
@@ -1386,7 +1320,7 @@ public function testSpatialQueryCombinations(): void
                 'location' => [40.6602, -73.9690],
                 'area' => [[[40.6502, -73.9790], [40.6502, -73.9590], [40.6702, -73.9590], [40.6702, -73.9790], [40.6502, -73.9790]]],
                 'route' => [[40.6502, -73.9790], [40.6702, -73.9590]],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]);
 
             $doc3 = new Document([
@@ -1395,7 +1329,7 @@ public function testSpatialQueryCombinations(): void
                 'location' => [40.6033, -74.0170],
                 'area' => [[[40.5933, -74.0270], [40.5933, -74.0070], [40.6133, -74.0070], [40.6133, -74.0270], [40.5933, -74.0270]]],
                 'route' => [[40.5933, -74.0270], [40.6133, -74.0070]],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]);
 
             $database->createDocument($collectionName, $doc1);
@@ -1404,13 +1338,13 @@ public function testSpatialQueryCombinations(): void
 
             // Test complex spatial queries with logical combinations
             // Test AND combination: parks within area AND near specific location
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $nearbyAndInArea = $database->find($collectionName, [
                     Query::and([
                         Query::distanceLessThan('location', [40.7829, -73.9654], 0.01), // Near Central Park
-                        Query::contains('area', [[40.7829, -73.9654]]) // Location is within area
-                    ])
-                ], Database::PERMISSION_READ);
+                        Query::covers('area', [[40.7829, -73.9654]]), // Location is within area
+                    ]),
+                ], PermissionType::Read);
                 $this->assertNotEmpty($nearbyAndInArea);
                 $this->assertEquals('park1', $nearbyAndInArea[0]->getId());
             }
@@ -1419,47 +1353,47 @@ public function testSpatialQueryCombinations(): void
             $nearEitherLocation = $database->find($collectionName, [
                 Query::or([
                     Query::distanceLessThan('location', [40.7829, -73.9654], 0.01), // Near Central Park
-                    Query::distanceLessThan('location', [40.6602, -73.9690], 0.01) // Near Prospect Park
-                ])
-            ], Database::PERMISSION_READ);
+                    Query::distanceLessThan('location', [40.6602, -73.9690], 0.01), // Near Prospect Park
+                ]),
+            ], PermissionType::Read);
             $this->assertCount(2, $nearEitherLocation);
 
             // Test distanceGreaterThan: parks far from Central Park
             $farFromCentral = $database->find($collectionName, [
-                Query::distanceGreaterThan('location', [40.7829, -73.9654], 0.1) // More than 0.1 degrees from Central Park
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('location', [40.7829, -73.9654], 0.1), // More than 0.1 degrees from Central Park
+            ], PermissionType::Read);
             $this->assertNotEmpty($farFromCentral);
 
             // Test distanceLessThan: parks very close to Central Park
             $veryCloseToCentral = $database->find($collectionName, [
-                Query::distanceLessThan('location', [40.7829, -73.9654], 0.001) // Less than 0.001 degrees from Central Park
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('location', [40.7829, -73.9654], 0.001), // Less than 0.001 degrees from Central Park
+            ], PermissionType::Read);
             $this->assertNotEmpty($veryCloseToCentral);
 
             // Test distanceGreaterThan with various thresholds
             // Test: parks more than 0.3 degrees from Central Park (should find none since all parks are closer)
             $veryFarFromCentral = $database->find($collectionName, [
-                Query::distanceGreaterThan('location', [40.7829, -73.9654], 0.3)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('location', [40.7829, -73.9654], 0.3),
+            ], PermissionType::Read);
             $this->assertCount(0, $veryFarFromCentral);
 
             // Test: parks more than 0.3 degrees from Prospect Park (should find other parks)
             $farFromProspect = $database->find($collectionName, [
-                Query::distanceGreaterThan('location', [40.6602, -73.9690], 0.1)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('location', [40.6602, -73.9690], 0.1),
+            ], PermissionType::Read);
             $this->assertNotEmpty($farFromProspect);
 
             // Test: parks more than 0.3 degrees from Times Square (should find none since all parks are closer)
             $farFromTimesSquare = $database->find($collectionName, [
-                Query::distanceGreaterThan('location', [40.7589, -73.9851], 0.3)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('location', [40.7589, -73.9851], 0.3),
+            ], PermissionType::Read);
             $this->assertCount(0, $farFromTimesSquare);
 
             // Test ordering by distanceEqual from a specific point
             $orderedByDistance = $database->find($collectionName, [
                 Query::distanceLessThan('location', [40.7829, -73.9654], 0.01), // Within ~1km
-                Query::limit(10)
-            ], Database::PERMISSION_READ);
+                Query::limit(10),
+            ], PermissionType::Read);
 
             $this->assertNotEmpty($orderedByDistance);
             // First result should be closest to the reference point
@@ -1468,8 +1402,8 @@ public function testSpatialQueryCombinations(): void
             // Test spatial queries with limits
             $limitedResults = $database->find($collectionName, [
                 Query::distanceLessThan('location', [40.7829, -73.9654], 1.0), // Within 1 degree
-                Query::limit(2)
-            ], Database::PERMISSION_READ);
+                Query::limit(2),
+            ], PermissionType::Read);
 
             $this->assertCount(2, $limitedResults);
         } finally {
@@ -1481,18 +1415,18 @@ public function testSpatialIsNullIsNotNull(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
         $collectionName = 'spatial_null_checks';
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'name', Database::VAR_STRING, 255, true));
+            $this->assertTrue($database->createAttribute($collectionName, Attribute::string(key: 'name', required: true)));
             // Optional spatial attribute: some documents legitimately have no location set.
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'location', Database::VAR_POINT, 0, false));
+            $this->assertTrue($database->createAttribute($collectionName, Attribute::point(key: 'location')));
 
             $database->createDocument($collectionName, new Document([
                 '$id' => 'withLocation',
@@ -1510,13 +1444,13 @@ public function testSpatialIsNullIsNotNull(): void
 
             $withLocation = $database->find($collectionName, [
                 Query::isNotNull('location'),
-            ], Database::PERMISSION_READ);
+            ], PermissionType::Read);
             $this->assertCount(1, $withLocation);
             $this->assertEquals('withLocation', $withLocation[0]->getId());
 
             $withoutLocation = $database->find($collectionName, [
                 Query::isNull('location'),
-            ], Database::PERMISSION_READ);
+            ], PermissionType::Read);
             $this->assertCount(1, $withoutLocation);
             $this->assertEquals('withoutLocation', $withoutLocation[0]->getId());
         } finally {
@@ -1528,8 +1462,9 @@ public function testSpatialBulkOperation(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1537,43 +1472,16 @@ public function testSpatialBulkOperation(): void
 
         // Create collection with spatial attributes
         $attributes = [
-            new Document([
-                '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-            ]),
-            new Document([
-                '$id' => ID::custom('location'),
-                'type' => Database::VAR_POINT,
-                'size' => 0,
-                'required' => true,
-                'signed' => true,
-                'array' => false,
-            ]),
-            new Document([
-                '$id' => ID::custom('area'),
-                'type' => Database::VAR_POLYGON,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-            ])
+            Attribute::string(key: 'name', size: 256, required: true),
+            Attribute::point(key: 'location', required: true),
+            Attribute::polygon(key: 'area'),
         ];
 
         $indexes = [
-            new Document([
-                '$id' => ID::custom('spatial_idx'),
-                'type' => Database::INDEX_SPATIAL,
-                'attributes' => ['location'],
-                'lengths' => [],
-                'orders' => [],
-            ])
+            Index::spatial(key: 'spatial_idx', attributes: ['location']),
         ];
 
-        $database->createCollection($collectionName, $attributes, $indexes);
+        $database->createCollection(new Collection(id: $collectionName, attributes: $attributes, indexes: $indexes));
 
         // Test 1: createDocuments with spatial data
         $spatialDocuments = [];
@@ -1585,15 +1493,15 @@ public function testSpatialBulkOperation(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-                'name' => 'Location ' . $i,
+                'name' => 'Location '.$i,
                 'location' => [10.0 + $i, 20.0 + $i], // POINT
                 'area' => [
                     [10.0 + $i, 20.0 + $i],
                     [11.0 + $i, 20.0 + $i],
                     [11.0 + $i, 21.0 + $i],
                     [10.0 + $i, 21.0 + $i],
-                    [10.0 + $i, 20.0 + $i]
-                ] // POLYGON
+                    [10.0 + $i, 20.0 + $i],
+                ], // POLYGON
             ]);
         }
 
@@ -1610,10 +1518,12 @@ public function testSpatialBulkOperation(): void
             $this->assertNotEmpty($document->getId());
             $this->assertNotEmpty($document->getAttribute('name'));
             $this->assertNotEmpty($document->getSequence());
-            $this->assertIsArray($document->getAttribute('location'));
-            $this->assertIsArray($document->getAttribute('area'));
-            $this->assertCount(2, $document->getAttribute('location')); // POINT has 2 coordinates
-            $this->assertGreaterThan(1, count($document->getAttribute('area')[0])); // POLYGON has multiple points
+            $location = $document->getArray('location');
+            $area = $document->getArray('area');
+            $this->assertCount(2, $location);
+            $ring = $area[0] ?? null;
+            $this->assertIsArray($ring);
+            $this->assertGreaterThan(1, count($ring));
         }
 
         $results = $database->find($collectionName);
@@ -1621,10 +1531,12 @@ public function testSpatialBulkOperation(): void
             $this->assertNotEmpty($document->getId());
             $this->assertNotEmpty($document->getAttribute('name'));
             $this->assertNotEmpty($document->getSequence());
-            $this->assertIsArray($document->getAttribute('location'));
-            $this->assertIsArray($document->getAttribute('area'));
-            $this->assertCount(2, $document->getAttribute('location')); // POINT has 2 coordinates
-            $this->assertGreaterThan(1, count($document->getAttribute('area')[0])); // POLYGON has multiple points
+            $location = $document->getArray('location');
+            $area = $document->getArray('area');
+            $this->assertCount(2, $location);
+            $ring = $area[0] ?? null;
+            $this->assertIsArray($ring);
+            $this->assertGreaterThan(1, count($ring));
         }
 
         foreach ($results as $doc) {
@@ -1633,26 +1545,36 @@ public function testSpatialBulkOperation(): void
             $this->assertNotEmpty($document->getAttribute('name'));
             $this->assertEquals($document->getAttribute('name'), $doc->getAttribute('name'));
             $this->assertNotEmpty($document->getSequence());
-            $this->assertIsArray($document->getAttribute('location'));
-            $this->assertIsArray($document->getAttribute('area'));
-            $this->assertCount(2, $document->getAttribute('location')); // POINT has 2 coordinates
-            $this->assertGreaterThan(1, count($document->getAttribute('area')[0])); // POLYGON has multiple points
+            $location = $document->getArray('location');
+            $area = $document->getArray('area');
+            $this->assertCount(2, $location);
+            $ring = $area[0] ?? null;
+            $this->assertIsArray($ring);
+            $this->assertGreaterThan(1, count($ring));
         }
 
-        $results = $database->find($collectionName, [Query::select(["name"])]);
+        $results = $database->find($collectionName, [Query::select(['name'])]);
         foreach ($results as $document) {
             $this->assertNotEmpty($document->getAttribute('name'));
         }
 
-        $results = $database->find($collectionName, [Query::select(["location"])]);
+        $results = $database->find($collectionName, [Query::select(['location'])]);
         foreach ($results as $document) {
-            $this->assertCount(2, $document->getAttribute('location')); // POINT has 2 coordinates
+            $location = $document->getAttribute('location');
+            $this->assertIsArray($location);
+            $this->assertCount(2, $location); // POINT has 2 coordinates
         }
 
-        $results = $database->find($collectionName, [Query::select(["area","location"])]);
+        $results = $database->find($collectionName, [Query::select(['area', 'location'])]);
         foreach ($results as $document) {
-            $this->assertCount(2, $document->getAttribute('location')); // POINT has 2 coordinates
-            $this->assertGreaterThan(1, count($document->getAttribute('area')[0])); // POLYGON has multiple points
+            $location = $document->getAttribute('location');
+            $this->assertIsArray($location);
+            $this->assertCount(2, $location); // POINT has 2 coordinates
+            $area = $document->getAttribute('area');
+            $this->assertIsArray($area);
+            $ring = $area[0] ?? null;
+            $this->assertIsArray($ring);
+            $this->assertGreaterThan(1, count($ring)); // POLYGON has multiple points
         }
 
         // Test 2: updateDocuments with spatial data
@@ -1665,10 +1587,10 @@ public function testSpatialBulkOperation(): void
                 [16.0, 25.0],
                 [16.0, 26.0],
                 [15.0, 26.0],
-                [15.0, 25.0]
-            ] // New POLYGON
+                [15.0, 25.0],
+            ], // New POLYGON
         ]), [
-            Query::greaterThanEqual('$sequence', $results[0]->getSequence())
+            Query::greaterThanEqual('$sequence', $results[0]->getSequence() ?? ''),
         ], onNext: function ($doc) use (&$updateResults) {
             $updateResults[] = $doc;
         });
@@ -1678,9 +1600,9 @@ public function testSpatialBulkOperation(): void
             $database->updateDocuments($collectionName, new Document([
                 'name' => 'Updated Location',
                 'location' => [15.0, 25.0],
-                'area' => [15.0, 25.0] // invalid polygon
+                'area' => [15.0, 25.0], // invalid polygon
             ]));
-            $this->fail("fail to throw structure exception for the invalid spatial type");
+            $this->fail('fail to throw structure exception for the invalid spatial type');
         } catch (\Throwable $th) {
             $this->assertInstanceOf(StructureException::class, $th);
 
@@ -1697,7 +1619,7 @@ public function testSpatialBulkOperation(): void
                 [16.0, 25.0],
                 [16.0, 26.0],
                 [15.0, 26.0],
-                [15.0, 25.0]
+                [15.0, 25.0],
             ]], $document->getAttribute('area'));
         }
 
@@ -1718,8 +1640,8 @@ public function testSpatialBulkOperation(): void
                     [31.0, 40.0],
                     [31.0, 41.0],
                     [30.0, 41.0],
-                    [30.0, 40.0]
-                ]
+                    [30.0, 40.0],
+                ],
             ]),
             new Document([
                 '$id' => 'upsert2',
@@ -1736,9 +1658,9 @@ public function testSpatialBulkOperation(): void
                     [36.0, 45.0],
                     [36.0, 46.0],
                     [35.0, 46.0],
-                    [35.0, 45.0]
-                ]
-            ])
+                    [35.0, 45.0],
+                ],
+            ]),
         ];
 
         $upsertResults = [];
@@ -1753,71 +1675,71 @@ public function testSpatialBulkOperation(): void
         foreach ($upsertResults as $document) {
             $this->assertNotEmpty($document->getId());
             $this->assertNotEmpty($document->getSequence());
-            $this->assertIsArray($document->getAttribute('location'));
-            $this->assertIsArray($document->getAttribute('area'));
+            $this->assertNotEmpty($document->getArray('location'));
+            $this->assertNotEmpty($document->getArray('area'));
         }
 
         // Test 4: Query spatial data after bulk operations
         $allDocuments = $database->find($collectionName, [
-            Query::orderAsc('$sequence')
+            Query::orderAsc('$sequence'),
         ]);
 
         $this->assertGreaterThan(5, count($allDocuments)); // Should have original 5 + upserted 2
 
         // Test 5: Spatial queries on bulk created data
         $nearbyDocuments = $database->find($collectionName, [
-            Query::distanceLessThan('location', [15.0, 25.0], 1.0) // Find documents within 1 unit
+            Query::distanceLessThan('location', [15.0, 25.0], 1.0), // Find documents within 1 unit
         ]);
 
         $this->assertGreaterThan(0, count($nearbyDocuments));
 
         // Test 6: distanceGreaterThan queries on bulk created data
         $farDocuments = $database->find($collectionName, [
-            Query::distanceGreaterThan('location', [15.0, 25.0], 5.0) // Find documents more than 5 units away
+            Query::distanceGreaterThan('location', [15.0, 25.0], 5.0), // Find documents more than 5 units away
         ]);
 
         $this->assertGreaterThan(0, count($farDocuments));
 
         // Test 7: distanceLessThan queries on bulk created data
         $closeDocuments = $database->find($collectionName, [
-            Query::distanceLessThan('location', [15.0, 25.0], 0.5) // Find documents less than 0.5 units away
+            Query::distanceLessThan('location', [15.0, 25.0], 0.5), // Find documents less than 0.5 units away
         ]);
 
         $this->assertGreaterThan(0, count($closeDocuments));
 
         // Test 8: Additional distanceGreaterThan queries on bulk created data
         $veryFarDocuments = $database->find($collectionName, [
-            Query::distanceGreaterThan('location', [15.0, 25.0], 10.0) // Find documents more than 10 units away
+            Query::distanceGreaterThan('location', [15.0, 25.0], 10.0), // Find documents more than 10 units away
         ]);
 
         $this->assertGreaterThan(0, count($veryFarDocuments));
 
         // Test 9: distanceGreaterThan with very small threshold (should find most documents)
         $slightlyFarDocuments = $database->find($collectionName, [
-            Query::distanceGreaterThan('location', [15.0, 25.0], 0.1) // Find documents more than 0.1 units away
+            Query::distanceGreaterThan('location', [15.0, 25.0], 0.1), // Find documents more than 0.1 units away
         ]);
 
         $this->assertGreaterThan(0, count($slightlyFarDocuments));
 
         // Test 10: distanceGreaterThan with very large threshold (should find none)
         $extremelyFarDocuments = $database->find($collectionName, [
-            Query::distanceGreaterThan('location', [15.0, 25.0], 100.0) // Find documents more than 100 units away
+            Query::distanceGreaterThan('location', [15.0, 25.0], 100.0), // Find documents more than 100 units away
         ]);
 
         $this->assertEquals(0, count($extremelyFarDocuments));
 
         // Test 11: Update specific spatial documents
         $specificUpdateCount = $database->updateDocuments($collectionName, new Document([
-            'name' => 'Specifically Updated'
+            'name' => 'Specifically Updated',
         ]), [
-            Query::equal('$id', ['upsert1'])
+            Query::equal('$id', ['upsert1']),
         ]);
 
         $this->assertEquals(1, $specificUpdateCount);
 
         // Verify the specific update
         $specificDoc = $database->find($collectionName, [
-            Query::equal('$id', ['upsert1'])
+            Query::equal('$id', ['upsert1']),
         ]);
 
         $this->assertCount(1, $specificDoc);
@@ -1831,56 +1753,53 @@ public function testSptialAggregation(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
         $collectionName = 'spatial_agg_';
         try {
             // Create collection with spatial and numeric attributes
-            $database->createCollection($collectionName);
-            $database->createAttribute($collectionName, 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute($collectionName, 'loc', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collectionName, 'area', Database::VAR_POLYGON, 0, true);
-            $database->createAttribute($collectionName, 'score', Database::VAR_INTEGER, 0, true);
+            $database->createCollection(new Collection(id: $collectionName));
+            $database->createAttribute($collectionName, Attribute::string(key: 'name', required: true));
+            $database->createAttribute($collectionName, Attribute::point(key: 'loc', required: true));
+            $database->createAttribute($collectionName, Attribute::polygon(key: 'area', required: true));
+            $database->createAttribute($collectionName, Attribute::integer(key: 'score', required: true));
 
             // Spatial indexes
-            $database->createIndex($collectionName, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
-            $database->createIndex($collectionName, 'idx_area', Database::INDEX_SPATIAL, ['area']);
+            $database->createIndex($collectionName, Index::spatial(key: 'idx_loc', attributes: ['loc']));
+            $database->createIndex($collectionName, Index::spatial(key: 'idx_area', attributes: ['area']));
 
             // Seed documents
-            $a = $database->createDocument($collectionName, new Document([
+            $database->createDocument($collectionName, new Document([
                 '$id' => 'a',
                 'name' => 'A',
                 'loc' => [10.0, 10.0],
                 'area' => [[[9.0, 9.0], [9.0, 11.0], [11.0, 11.0], [11.0, 9.0], [9.0, 9.0]]],
                 'score' => 10,
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $b = $database->createDocument($collectionName, new Document([
+            $database->createDocument($collectionName, new Document([
                 '$id' => 'b',
                 'name' => 'B',
                 'loc' => [10.05, 10.05],
                 'area' => [[[9.5, 9.5], [9.5, 10.6], [10.6, 10.6], [10.6, 9.5], [9.5, 9.5]]],
                 'score' => 20,
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $c = $database->createDocument($collectionName, new Document([
+            $database->createDocument($collectionName, new Document([
                 '$id' => 'c',
                 'name' => 'C',
                 'loc' => [50.0, 50.0],
                 'area' => [[[49.0, 49.0], [49.0, 51.0], [51.0, 51.0], [51.0, 49.0], [49.0, 49.0]]],
                 'score' => 30,
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
 
-            $this->assertInstanceOf(Document::class, $a);
-            $this->assertInstanceOf(Document::class, $b);
-            $this->assertInstanceOf(Document::class, $c);
-
             // COUNT with spatial distanceEqual filter
             $queries = [
-                Query::distanceLessThan('loc', [10.0, 10.0], 0.1)
+                Query::distanceLessThan('loc', [10.0, 10.0], 0.1),
             ];
             $this->assertEquals(2, $database->count($collectionName, $queries));
             $this->assertCount(2, $database->find($collectionName, $queries));
@@ -1891,21 +1810,21 @@ public function testSptialAggregation(): void
 
             // COUNT and SUM with distanceGreaterThan (should only include far point "c")
             $queriesFar = [
-                Query::distanceGreaterThan('loc', [10.0, 10.0], 10.0)
+                Query::distanceGreaterThan('loc', [10.0, 10.0], 10.0),
             ];
             $this->assertEquals(1, $database->count($collectionName, $queriesFar));
             $this->assertEquals(30, $database->sum($collectionName, 'score', $queriesFar));
 
             // COUNT and SUM with polygon contains filter (adapter-dependent boundary inclusivity)
-            if ($database->getAdapter()->getSupportForBoundaryInclusiveContains()) {
+            if ($database->getAdapter()->supports(Capability::BoundaryInclusive)) {
                 $queriesContain = [
-                    Query::contains('area', [[10.0, 10.0]])
+                    Query::covers('area', [[10.0, 10.0]]),
                 ];
                 $this->assertEquals(2, $database->count($collectionName, $queriesContain));
                 $this->assertEquals(30, $database->sum($collectionName, 'score', $queriesContain));
 
                 $queriesNotContain = [
-                    Query::notContains('area', [[10.0, 10.0]])
+                    Query::notCovers('area', [[10.0, 10.0]]),
                 ];
                 $this->assertEquals(1, $database->count($collectionName, $queriesNotContain));
                 $this->assertEquals(30, $database->sum($collectionName, 'score', $queriesNotContain));
@@ -1919,33 +1838,34 @@ public function testUpdateSpatialAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'spatial_update_attrs_';
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
 
             // 0) Disallow creation of spatial attributes with size or array
             try {
-                $database->createAttribute($collectionName, 'geom_bad_size', Database::VAR_POINT, 10, true);
+                $database->createAttribute($collectionName, Attribute::point(key: 'geom_bad_size', size: 10, required: true));
                 $this->fail('Expected DatabaseException when creating spatial attribute with non-zero size');
             } catch (\Throwable $e) {
                 $this->assertInstanceOf(Exception::class, $e);
             }
 
             try {
-                $database->createAttribute($collectionName, 'geom_bad_array', Database::VAR_POINT, 0, true, array: true);
+                $database->createAttribute($collectionName, Attribute::point(key: 'geom_bad_array', required: true, array: true));
                 $this->fail('Expected DatabaseException when creating spatial attribute with array=true');
             } catch (\Throwable $e) {
                 $this->assertInstanceOf(Exception::class, $e);
             }
 
             // Create a single spatial attribute (required=true)
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'geom', Database::VAR_POINT, 0, true));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_geom', Database::INDEX_SPATIAL, ['geom']));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'geom', required: true)));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_geom', attributes: ['geom'])));
 
             // 1) Disallow size and array updates on spatial attributes: expect DatabaseException
             try {
@@ -1963,12 +1883,15 @@ public function testUpdateSpatialAttributes(): void
             }
 
             // 2) required=true -> create index -> update required=false
-            $nullSupported = $database->getAdapter()->getSupportForSpatialIndexNull();
+            $nullSupported = $database->getAdapter()->supports(Capability::SpatialIndexNull);
             if ($nullSupported) {
                 // Should succeed on adapters that allow nullable spatial indexes
                 $database->updateAttribute($collectionName, 'geom', required: false);
                 $meta = $database->getCollection($collectionName);
-                $this->assertEquals(false, $meta->getAttribute('attributes')[0]['required']);
+                $attributes = $meta->attributes;
+                $attribute = $attributes[0] ?? null;
+                $this->assertInstanceOf(Document::class, $attribute);
+                $this->assertFalse($attribute->getAttribute('required'));
             } else {
                 // Should error (index constraint) when making required=false while spatial index exists
                 $threw = false;
@@ -1980,21 +1903,24 @@ public function testUpdateSpatialAttributes(): void
                 $this->assertTrue($threw, 'Expected error when setting required=false with existing spatial index and adapter not supporting nullable indexes');
                 // Ensure attribute remains required
                 $meta = $database->getCollection($collectionName);
-                $this->assertEquals(true, $meta->getAttribute('attributes')[0]['required']);
+                $attributes = $meta->attributes;
+                $attribute = $attributes[0] ?? null;
+                $this->assertInstanceOf(Document::class, $attribute);
+                $this->assertTrue($attribute->getAttribute('required'));
             }
 
             // 3) Spatial index order support: providing orders should fail if not supported
-            $orderSupported = $database->getAdapter()->getSupportForSpatialIndexOrder();
+            $orderSupported = $database->getAdapter()->supports(Capability::SpatialIndexOrder);
             if ($orderSupported) {
-                $this->assertTrue($database->createIndex($collectionName, 'idx_geom_desc', Database::INDEX_SPATIAL, ['geom'], [], [Database::ORDER_DESC]));
+                $this->assertTrue($database->createIndex($collectionName, Index::spatial(key: 'idx_geom_desc', attributes: ['geom'], orders: [Order::Desc])));
                 // cleanup
                 $this->assertTrue($database->deleteIndex($collectionName, 'idx_geom_desc'));
             } else {
                 try {
-                    $database->createIndex($collectionName, 'idx_geom_desc', Database::INDEX_SPATIAL, ['geom'], [], ['DESC']);
+                    $database->createIndex($collectionName, Index::spatial(key: 'idx_geom_desc', attributes: ['geom'], orders: [Order::Desc]));
                     $this->fail('Expected error when providing orders for spatial index on adapter without order support');
                 } catch (\Throwable $e) {
-                    $this->assertTrue(true);
+                    $this->assertNotSame('', $e->getMessage());
                 }
             }
         } finally {
@@ -2002,281 +1928,68 @@ public function testUpdateSpatialAttributes(): void
         }
     }
 
-    public function testSpatialAttributeDefaults(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = 'spatial_defaults_';
-        try {
-            $database->createCollection($collectionName);
-
-            // Create spatial attributes with defaults and no indexes to avoid nullability/index constraints
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'pt', Database::VAR_POINT, 0, false, [1.0, 2.0]));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'ln', Database::VAR_LINESTRING, 0, false, [[0.0, 0.0], [1.0, 1.0]]));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'pg', Database::VAR_POLYGON, 0, false, [[[0.0, 0.0], [0.0, 2.0], [2.0, 2.0], [0.0, 0.0]]]));
-
-            // Create non-spatial attributes (mix of defaults and no defaults)
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'title', Database::VAR_STRING, 255, false, 'Untitled'));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'count', Database::VAR_INTEGER, 0, false, 0));
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'rating', Database::VAR_FLOAT, 0, false)); // no default
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'active', Database::VAR_BOOLEAN, 0, false, true));
-
-            // Create document without providing spatial values, expect defaults applied
-            $doc = $database->createDocument($collectionName, new Document([
-                '$id' => ID::custom('d1'),
-                '$permissions' => [Permission::read(Role::any())]
-            ]));
-            $this->assertInstanceOf(Document::class, $doc);
-            $this->assertEquals([1.0, 2.0], $doc->getAttribute('pt'));
-            $this->assertEquals([[0.0, 0.0], [1.0, 1.0]], $doc->getAttribute('ln'));
-            $this->assertEquals([[[0.0, 0.0], [0.0, 2.0], [2.0, 2.0], [0.0, 0.0]]], $doc->getAttribute('pg'));
-            // Non-spatial defaults
-            $this->assertEquals('Untitled', $doc->getAttribute('title'));
-            $this->assertEquals(0, $doc->getAttribute('count'));
-            $this->assertNull($doc->getAttribute('rating'));
-            $this->assertTrue($doc->getAttribute('active'));
-
-            // Create document overriding defaults
-            $doc2 = $database->createDocument($collectionName, new Document([
-                '$id' => ID::custom('d2'),
-                '$permissions' => [Permission::read(Role::any())],
-                'pt' => [9.0, 9.0],
-                'ln' => [[2.0, 2.0], [3.0, 3.0]],
-                'pg' => [[[1.0, 1.0], [1.0, 3.0], [3.0, 3.0], [1.0, 1.0]]],
-                'title' => 'Custom',
-                'count' => 5,
-                'rating' => 4.5,
-                'active' => false
-            ]));
-            $this->assertInstanceOf(Document::class, $doc2);
-            $this->assertEquals([9.0, 9.0], $doc2->getAttribute('pt'));
-            $this->assertEquals([[2.0, 2.0], [3.0, 3.0]], $doc2->getAttribute('ln'));
-            $this->assertEquals([[[1.0, 1.0], [1.0, 3.0], [3.0, 3.0], [1.0, 1.0]]], $doc2->getAttribute('pg'));
-            $this->assertEquals('Custom', $doc2->getAttribute('title'));
-            $this->assertEquals(5, $doc2->getAttribute('count'));
-            $this->assertEquals(4.5, $doc2->getAttribute('rating'));
-            $this->assertFalse($doc2->getAttribute('active'));
-
-            // Update defaults and ensure they are applied for new documents
-            $database->updateAttributeDefault($collectionName, 'pt', [5.0, 6.0]);
-            $database->updateAttributeDefault($collectionName, 'ln', [[10.0, 10.0], [20.0, 20.0]]);
-            $database->updateAttributeDefault($collectionName, 'pg', [[[5.0, 5.0], [5.0, 7.0], [7.0, 7.0], [5.0, 5.0]]]);
-            $database->updateAttributeDefault($collectionName, 'title', 'Updated');
-            $database->updateAttributeDefault($collectionName, 'count', 10);
-            $database->updateAttributeDefault($collectionName, 'active', false);
-
-            $doc3 = $database->createDocument($collectionName, new Document([
-                '$id' => ID::custom('d3'),
-                '$permissions' => [Permission::read(Role::any())]
-            ]));
-            $this->assertInstanceOf(Document::class, $doc3);
-            $this->assertEquals([5.0, 6.0], $doc3->getAttribute('pt'));
-            $this->assertEquals([[10.0, 10.0], [20.0, 20.0]], $doc3->getAttribute('ln'));
-            $this->assertEquals([[[5.0, 5.0], [5.0, 7.0], [7.0, 7.0], [5.0, 5.0]]], $doc3->getAttribute('pg'));
-            $this->assertEquals('Updated', $doc3->getAttribute('title'));
-            $this->assertEquals(10, $doc3->getAttribute('count'));
-            $this->assertNull($doc3->getAttribute('rating'));
-            $this->assertFalse($doc3->getAttribute('active'));
-
-            // Invalid defaults should raise errors
-            try {
-                $database->updateAttributeDefault($collectionName, 'pt', [[1.0, 2.0]]); // wrong dimensionality
-                $this->fail('Expected exception for invalid point default shape');
-            } catch (\Throwable $e) {
-                $this->assertTrue(true);
-            }
-            try {
-                $database->updateAttributeDefault($collectionName, 'ln', [1.0, 2.0]); // wrong dimensionality
-                $this->fail('Expected exception for invalid linestring default shape');
-            } catch (\Throwable $e) {
-                $this->assertTrue(true);
-            }
-            try {
-                $database->updateAttributeDefault($collectionName, 'pg', [[1.0, 2.0]]); // wrong dimensionality
-                $this->fail('Expected exception for invalid polygon default shape');
-            } catch (\Throwable $e) {
-                $this->assertTrue(true);
-            }
-        } finally {
-            $database->deleteCollection($collectionName);
-        }
-    }
-
-    public function testInvalidSpatialTypes(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = 'test_invalid_spatial_types';
-
-        $attributes = [
-            new Document([
-                '$id' => ID::custom('pointAttr'),
-                'type' => Database::VAR_POINT,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('lineAttr'),
-                'type' => Database::VAR_LINESTRING,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
-            new Document([
-                '$id' => ID::custom('polyAttr'),
-                'type' => Database::VAR_POLYGON,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ])
-        ];
-
-        $database->createCollection($collectionName, $attributes);
-
-        // Invalid Point (must be [x, y])
-        try {
-            $database->createDocument($collectionName, new Document([
-                'pointAttr' => [10.0], // only 1 coordinate
-            ]));
-            $this->fail("Expected StructureException for invalid point");
-        } catch (\Throwable $th) {
-            $this->assertInstanceOf(StructureException::class, $th);
-        }
-
-        // Invalid LineString (must be [[x,y],[x,y],...], at least 2 points)
-        try {
-            $database->createDocument($collectionName, new Document([
-                'lineAttr' => [[10.0, 20.0]], // only one point
-            ]));
-            $this->fail("Expected StructureException for invalid line");
-        } catch (\Throwable $th) {
-            $this->assertInstanceOf(StructureException::class, $th);
-        }
-
-        try {
-            $database->createDocument($collectionName, new Document([
-                'lineAttr' => [10.0, 20.0], // not an array of arrays
-            ]));
-            $this->fail("Expected StructureException for invalid line structure");
-        } catch (\Throwable $th) {
-            $this->assertInstanceOf(StructureException::class, $th);
-        }
-
-        try {
-            $database->createDocument($collectionName, new Document([
-                'polyAttr' => [10.0, 20.0] // not an array of arrays
-            ]));
-            $this->fail("Expected StructureException for invalid polygon structure");
-        } catch (\Throwable $th) {
-            $this->assertInstanceOf(StructureException::class, $th);
-        }
-
-        $invalidPolygons = [
-            [[0,0],[1,1],[0,1]],
-            [[0,0],['a',1],[1,1],[0,0]],
-            [[0,0],[1,0],[1,1],[0,1]],
-            [],
-            [[0,0,5],[1,0,5],[1,1,5],[0,0,5]],
-            [
-                [[0,0],[2,0],[2,2],[0,0]], // valid
-                [[0,0,1],[1,0,1],[1,1,1],[0,0,1]] // invalid 3D
-            ]
-        ];
-        foreach ($invalidPolygons as $invalidPolygon) {
-            try {
-                $database->createDocument($collectionName, new Document([
-                    'polyAttr' => $invalidPolygon
-                ]));
-                $this->fail("Expected StructureException for invalid polygon structure");
-            } catch (\Throwable $th) {
-                $this->assertInstanceOf(StructureException::class, $th);
-            }
-        }
-        // Cleanup
-        $database->deleteCollection($collectionName);
-    }
-
     public function testSpatialDistanceInMeter(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'spatial_distance_meters_';
         try {
-            $database->createCollection($collectionName);
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'loc', Database::VAR_POINT, 0, true));
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
+            $database->createCollection(new Collection(id: $collectionName));
+            $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'loc', required: true)));
+            $this->assertEquals(true, $database->createIndex($collectionName, Index::spatial(key: 'idx_loc', attributes: ['loc'])));
 
             // Two points roughly ~1000 meters apart by latitude delta (~0.009 deg ≈ 1km)
-            $p0 = $database->createDocument($collectionName, new Document([
+            $database->createDocument($collectionName, new Document([
                 '$id' => 'p0',
                 'loc' => [0.0000, 0.0000],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
-            $p1 = $database->createDocument($collectionName, new Document([
+            $database->createDocument($collectionName, new Document([
                 '$id' => 'p1',
                 'loc' => [0.0090, 0.0000],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
 
-            $this->assertInstanceOf(Document::class, $p0);
-            $this->assertInstanceOf(Document::class, $p1);
-
             // distanceLessThan with meters=true: within 1500m should include both
             $within1_5km = $database->find($collectionName, [
-                Query::distanceLessThan('loc', [0.0000, 0.0000], 1500, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('loc', [0.0000, 0.0000], 1500, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($within1_5km);
             $this->assertCount(2, $within1_5km);
 
             // Within 500m should include only p0 (exact point)
             $within500m = $database->find($collectionName, [
-                Query::distanceLessThan('loc', [0.0000, 0.0000], 500, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceLessThan('loc', [0.0000, 0.0000], 500, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($within500m);
             $this->assertCount(1, $within500m);
             $this->assertEquals('p0', $within500m[0]->getId());
 
             // distanceGreaterThan 500m should include only p1
             $greater500m = $database->find($collectionName, [
-                Query::distanceGreaterThan('loc', [0.0000, 0.0000], 500, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceGreaterThan('loc', [0.0000, 0.0000], 500, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($greater500m);
             $this->assertCount(1, $greater500m);
             $this->assertEquals('p1', $greater500m[0]->getId());
 
             // distanceEqual with 0m should return exact match p0
             $equalZero = $database->find($collectionName, [
-                Query::distanceEqual('loc', [0.0000, 0.0000], 0, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('loc', [0.0000, 0.0000], 0, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($equalZero);
             $this->assertEquals('p0', $equalZero[0]->getId());
 
             // distanceNotEqual with 0m should return p1
             $notEqualZero = $database->find($collectionName, [
-                Query::distanceNotEqual('loc', [0.0000, 0.0000], 0, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceNotEqual('loc', [0.0000, 0.0000], 0, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($notEqualZero);
             $this->assertEquals('p1', $notEqualZero[0]->getId());
         } finally {
@@ -2288,46 +2001,48 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForDistanceBetweenMultiDimensionGeometryInMeters()) {
+        if (! $database->getAdapter()->supports(Capability::MultiDimensionDistance)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $multiCollection = 'spatial_distance_meters_multi_';
         try {
-            $database->createCollection($multiCollection);
+            $database->createCollection(new Collection(id: $multiCollection));
 
             // Create spatial attributes
-            $this->assertEquals(true, $database->createAttribute($multiCollection, 'loc', Database::VAR_POINT, 0, true));
-            $this->assertEquals(true, $database->createAttribute($multiCollection, 'line', Database::VAR_LINESTRING, 0, true));
-            $this->assertEquals(true, $database->createAttribute($multiCollection, 'poly', Database::VAR_POLYGON, 0, true));
+            $this->assertEquals(true, $database->createAttribute($multiCollection, Attribute::point(key: 'loc', required: true)));
+            $this->assertEquals(true, $database->createAttribute($multiCollection, Attribute::linestring(key: 'line', required: true)));
+            $this->assertEquals(true, $database->createAttribute($multiCollection, Attribute::polygon(key: 'poly', required: true)));
 
             // Create indexes
-            $this->assertEquals(true, $database->createIndex($multiCollection, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
-            $this->assertEquals(true, $database->createIndex($multiCollection, 'idx_line', Database::INDEX_SPATIAL, ['line']));
-            $this->assertEquals(true, $database->createIndex($multiCollection, 'idx_poly', Database::INDEX_SPATIAL, ['poly']));
+            $this->assertEquals(true, $database->createIndex($multiCollection, Index::spatial(key: 'idx_loc', attributes: ['loc'])));
+            $this->assertEquals(true, $database->createIndex($multiCollection, Index::spatial(key: 'idx_line', attributes: ['line'])));
+            $this->assertEquals(true, $database->createIndex($multiCollection, Index::spatial(key: 'idx_poly', attributes: ['poly'])));
 
             // Geometry sets: near origin and far east
-            $docNear = $database->createDocument($multiCollection, new Document([
+            $database->createDocument($multiCollection, new Document([
                 '$id' => 'near',
                 'loc' => [0.0000, 0.0000],
                 'line' => [[0.0000, 0.0000], [0.0010, 0.0000]], // ~111m
                 'poly' => [[
                     [-0.0010, -0.0010],
                     [-0.0010,  0.0010],
-                    [ 0.0010,  0.0010],
-                    [ 0.0010, -0.0010],
-                    [-0.0010, -0.0010] // closed
+                    [0.0010,  0.0010],
+                    [0.0010, -0.0010],
+                    [-0.0010, -0.0010], // closed
                 ]],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
 
-            $docFar = $database->createDocument($multiCollection, new Document([
+            $database->createDocument($multiCollection, new Document([
                 '$id' => 'far',
                 'loc' => [0.2000, 0.0000], // ~22 km east
                 'line' => [[0.2000, 0.0000], [0.2020, 0.0000]],
@@ -2336,14 +2051,11 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                     [0.1980,  0.0020],
                     [0.2020,  0.0020],
                     [0.2020, -0.0020],
-                    [0.1980, -0.0020] // closed
+                    [0.1980, -0.0020], // closed
                 ]],
-                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())]
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
             ]));
 
-            $this->assertInstanceOf(Document::class, $docNear);
-            $this->assertInstanceOf(Document::class, $docFar);
-
             // polygon vs polygon (~1 km from near, ~22 km from far)
             $polyPolyWithin3km = $database->find($multiCollection, [
                 Query::distanceLessThan('poly', [[
@@ -2351,9 +2063,9 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                     [0.0080,  0.0010],
                     [0.0110,  0.0010],
                     [0.0110, -0.0010],
-                    [0.0080, -0.0010] // closed
-                ]], 3000, true)
-            ], Database::PERMISSION_READ);
+                    [0.0080, -0.0010], // closed
+                ]], 3000, true),
+            ], PermissionType::Read);
             $this->assertCount(1, $polyPolyWithin3km);
             $this->assertEquals('near', $polyPolyWithin3km[0]->getId());
 
@@ -2363,9 +2075,9 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                     [0.0080,  0.0010],
                     [0.0110,  0.0010],
                     [0.0110, -0.0010],
-                    [0.0080, -0.0010] // closed
-                ]], 3000, true)
-            ], Database::PERMISSION_READ);
+                    [0.0080, -0.0010], // closed
+                ]], 3000, true),
+            ], PermissionType::Read);
             $this->assertCount(1, $polyPolyGreater3km);
             $this->assertEquals('far', $polyPolyGreater3km[0]->getId());
 
@@ -2374,10 +2086,10 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                 Query::distanceLessThan('loc', [[
                     [-0.0010, -0.0010],
                     [-0.0010,  0.0020],
-                    [ 0.0020,  0.0020],
-                    [-0.0010, -0.0010]
-                ]], 500, true)
-            ], Database::PERMISSION_READ);
+                    [0.0020,  0.0020],
+                    [-0.0010, -0.0010],
+                ]], 500, true),
+            ], PermissionType::Read);
             $this->assertCount(1, $ptPolyWithin500);
             $this->assertEquals('near', $ptPolyWithin500[0]->getId());
 
@@ -2385,17 +2097,17 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                 Query::distanceGreaterThan('loc', [[
                     [-0.0010, -0.0010],
                     [-0.0010,  0.0020],
-                    [ 0.0020,  0.0020],
-                    [-0.0010, -0.0010]
-                ]], 500, true)
-            ], Database::PERMISSION_READ);
+                    [0.0020,  0.0020],
+                    [-0.0010, -0.0010],
+                ]], 500, true),
+            ], PermissionType::Read);
             $this->assertCount(1, $ptPolyGreater500);
             $this->assertEquals('far', $ptPolyGreater500[0]->getId());
 
             // Zero-distance checks
             $lineEqualZero = $database->find($multiCollection, [
-                Query::distanceEqual('line', [[0.0000, 0.0000], [0.0010, 0.0000]], 0, true)
-            ], Database::PERMISSION_READ);
+                Query::distanceEqual('line', [[0.0000, 0.0000], [0.0010, 0.0000]], 0, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($lineEqualZero);
             $this->assertEquals('near', $lineEqualZero[0]->getId());
 
@@ -2403,11 +2115,11 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                 Query::distanceEqual('poly', [[
                     [-0.0010, -0.0010],
                     [-0.0010,  0.0010],
-                    [ 0.0010,  0.0010],
-                    [ 0.0010, -0.0010],
-                    [-0.0010, -0.0010]
-                ]], 0, true)
-            ], Database::PERMISSION_READ);
+                    [0.0010,  0.0010],
+                    [0.0010, -0.0010],
+                    [-0.0010, -0.0010],
+                ]], 0, true),
+            ], PermissionType::Read);
             $this->assertNotEmpty($polyEqualZero);
             $this->assertEquals('near', $polyEqualZero[0]->getId());
 
@@ -2416,63 +2128,6 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
         }
     }
 
-    public function testSpatialDistanceInMeterError(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        if ($database->getAdapter()->getSupportForDistanceBetweenMultiDimensionGeometryInMeters()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'spatial_distance_error_test';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'loc', Database::VAR_POINT, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'line', Database::VAR_LINESTRING, 0, true));
-        $this->assertEquals(true, $database->createAttribute($collection, 'poly', Database::VAR_POLYGON, 0, true));
-
-        $doc = $database->createDocument($collection, new Document([
-            '$id' => 'doc1',
-            'loc' => [0.0, 0.0],
-            'line' => [[0.0, 0.0], [0.001, 0.0]],
-            'poly' => [[[ -0.001, -0.001 ], [ -0.001, 0.001 ], [ 0.001, 0.001 ], [ -0.001, -0.001 ]]],
-            '$permissions' => []
-        ]));
-        $this->assertInstanceOf(Document::class, $doc);
-
-        // Invalid geometry pairs
-        $cases = [
-            ['attr' => 'line', 'geom' => [0.002, 0.0], 'expected' => ['linestring', 'point']],
-            ['attr' => 'poly', 'geom' => [0.002, 0.0], 'expected' => ['polygon', 'point']],
-            ['attr' => 'loc', 'geom' => [[0.0, 0.0], [0.001, 0.001]], 'expected' => ['point', 'linestring']],
-            ['attr' => 'poly', 'geom' => [[0.0, 0.0], [0.001, 0.001]], 'expected' => ['polygon', 'linestring']],
-            ['attr' => 'loc', 'geom' => [[[0.0, 0.0], [0.001, 0.0], [0.001, 0.001], [0.0, 0.0]]], 'expected' => ['point', 'polygon']],
-            ['attr' => 'line', 'geom' => [[[0.0, 0.0], [0.001, 0.0], [0.001, 0.001], [0.0, 0.0]]], 'expected' => ['linestring', 'polygon']],
-            ['attr' => 'poly', 'geom' => [[[0.002, -0.001], [0.002, 0.001], [0.004, 0.001], [0.002, -0.001]]], 'expected' => ['polygon', 'polygon']],
-            ['attr' => 'line', 'geom' => [[0.002, 0.0], [0.003, 0.0]], 'expected' => ['linestring', 'linestring']],
-        ];
-
-        foreach ($cases as $case) {
-            try {
-                $database->find($collection, [
-                    Query::distanceLessThan($case['attr'], $case['geom'], 1000, true)
-                ]);
-                $this->fail('Expected Exception not thrown for ' . implode(' vs ', $case['expected']));
-            } catch (\Exception $e) {
-                $this->assertInstanceOf(QueryException::class, $e);
-
-                // Validate exception message contains correct type names
-                $msg = strtolower($e->getMessage());
-                $this->assertStringContainsString($case['expected'][0], $msg, 'Attr type missing in exception');
-                $this->assertStringContainsString($case['expected'][1], $msg, 'Geom type missing in exception');
-            }
-        }
-    }
     public function testSpatialEncodeDecode(): void
     {
         $collection = new Document([
@@ -2482,41 +2137,42 @@ public function testSpatialEncodeDecode(): void
             'attributes' => [
                 [
                     '$id' => ID::custom('point'),
-                    'type' => Database::VAR_POINT,
+                    'type' => ColumnType::Point->value,
                     'required' => false,
-                    'filters' => [Database::VAR_POINT],
+                    'filters' => [ColumnType::Point->value],
                 ],
                 [
                     '$id' => ID::custom('line'),
-                    'type' => Database::VAR_LINESTRING,
+                    'type' => ColumnType::Linestring->value,
                     'format' => '',
                     'required' => false,
-                    'filters' => [Database::VAR_LINESTRING],
+                    'filters' => [ColumnType::Linestring->value],
                 ],
                 [
                     '$id' => ID::custom('poly'),
-                    'type' => Database::VAR_POLYGON,
+                    'type' => ColumnType::Polygon->value,
                     'format' => '',
                     'required' => false,
-                    'filters' => [Database::VAR_POLYGON],
-                ]
-            ]
+                    'filters' => [ColumnType::Polygon->value],
+                ],
+            ],
         ]);
 
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        $point = "POINT(1 2)";
-        $line = "LINESTRING(1 2, 1 2)";
-        $poly = "POLYGON((0 0, 0 10, 10 10, 0 0))";
+        $point = 'POINT(1 2)';
+        $line = 'LINESTRING(1 2, 1 2)';
+        $poly = 'POLYGON((0 0, 0 10, 10 10, 0 0))';
 
-        $pointArr = [1,2];
-        $lineArr = [[1,2],[1,2]];
+        $pointArr = [1, 2];
+        $lineArr = [[1, 2], [1, 2]];
         $polyArr = [[[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [0.0, 0.0]]];
-        $doc = new Document(['point' => $pointArr ,'line' => $lineArr, 'poly' => $polyArr]);
+        $doc = new Document(['point' => $pointArr, 'line' => $lineArr, 'poly' => $polyArr]);
 
         $result = $database->encode($collection, $doc);
 
@@ -2524,103 +2180,52 @@ public function testSpatialEncodeDecode(): void
         $this->assertEquals($result->getAttribute('line'), $line);
         $this->assertEquals($result->getAttribute('poly'), $poly);
 
-
         $result = $database->decode($collection, $doc);
         $this->assertEquals($result->getAttribute('point'), $pointArr);
         $this->assertEquals($result->getAttribute('line'), $lineArr);
         $this->assertEquals($result->getAttribute('poly'), $polyArr);
 
-        $stringDoc = new Document(['point' => $point,'line' => $line, 'poly' => $poly]);
+        $stringDoc = new Document(['point' => $point, 'line' => $line, 'poly' => $poly]);
         $result = $database->decode($collection, $stringDoc);
         $this->assertEquals($result->getAttribute('point'), $pointArr);
         $this->assertEquals($result->getAttribute('line'), $lineArr);
         $this->assertEquals($result->getAttribute('poly'), $polyArr);
 
-        $nullDoc = new Document(['point' => null,'line' => null, 'poly' => null]);
+        $nullDoc = new Document(['point' => null, 'line' => null, 'poly' => null]);
         $result = $database->decode($collection, $nullDoc);
         $this->assertEquals($result->getAttribute('point'), null);
         $this->assertEquals($result->getAttribute('line'), null);
         $this->assertEquals($result->getAttribute('poly'), null);
     }
 
-    public function testSpatialIndexSingleAttributeOnly(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = 'spatial_idx_single_attr_' . uniqid();
-        try {
-            $database->createCollection($collectionName);
-
-            // Create a spatial attribute
-            $database->createAttribute($collectionName, 'loc', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collectionName, 'loc2', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collectionName, 'title', Database::VAR_STRING, 255, true);
-
-            // Case 1: Valid spatial index on a single spatial attribute
-            $this->assertTrue(
-                $database->createIndex($collectionName, 'idx_loc', Database::INDEX_SPATIAL, ['loc'])
-            );
-
-            // Case 2: Fail when trying to create spatial index with multiple attributes
-            try {
-                $database->createIndex($collectionName, 'idx_multi', Database::INDEX_SPATIAL, ['loc', 'loc2']);
-                $this->fail('Expected exception when creating spatial index on multiple attributes');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            // Case 3: Fail when trying to create non-spatial index on a spatial attribute
-            try {
-                $database->createIndex($collectionName, 'idx_wrong_type', Database::INDEX_KEY, ['loc']);
-                $this->fail('Expected exception when creating non-spatial index on spatial attribute');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            // Case 4: Fail when trying to mix spatial + non-spatial attributes in a spatial index
-            try {
-                $database->createIndex($collectionName, 'idx_mix', Database::INDEX_SPATIAL, ['loc', 'title']);
-                $this->fail('Expected exception when creating spatial index with mixed attribute types');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-        } finally {
-            $database->deleteCollection($collectionName);
-        }
-    }
-
     public function testSpatialIndexRequiredToggling(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        if ($database->getAdapter()->getSupportForSpatialIndexNull()) {
+        if ($database->getAdapter()->supports(Capability::SpatialIndexNull)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         try {
             $collUpdateNull = 'spatial_idx_toggle';
-            $database->createCollection($collUpdateNull);
+            $database->createCollection(new Collection(id: $collUpdateNull));
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
+            $database->createAttribute($collUpdateNull, Attribute::point(key: 'loc'));
             try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                $database->createIndex($collUpdateNull, Index::spatial(key: 'idx_loc', attributes: ['loc']));
                 $this->fail('Expected exception when creating spatial index on NULL-able attribute');
             } catch (\Throwable $e) {
                 $this->assertInstanceOf(Exception::class, $e);
             }
             $database->updateAttribute($collUpdateNull, 'loc', required: true);
-            $this->assertTrue($database->createIndex($collUpdateNull, 'new index', Database::INDEX_SPATIAL, ['loc']));
+            $this->assertTrue($database->createIndex($collUpdateNull, Index::spatial(key: 'new index', attributes: ['loc'])));
             $this->assertTrue($database->deleteIndex($collUpdateNull, 'new index'));
             $database->updateAttribute($collUpdateNull, 'loc', required: false);
 
@@ -2630,218 +2235,70 @@ public function testSpatialIndexRequiredToggling(): void
         }
     }
 
-    public function testSpatialIndexOnNonSpatial(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        try {
-            $collUpdateNull = 'spatial_idx_toggle';
-            $database->createCollection($collUpdateNull);
-
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collUpdateNull, 'name', Database::VAR_STRING, 4, true);
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['name']);
-                $this->fail('Expected exception when creating spatial index on NULL-able attribute');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_KEY, ['loc']);
-                $this->fail('Expected exception when creating non spatial index on spatial attribute');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_KEY, ['loc,name']);
-                $this->fail('Expected exception when creating index');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_KEY, ['name,loc']);
-                $this->fail('Expected exception when creating index');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['name,loc']);
-                $this->fail('Expected exception when creating index');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-            try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc,name']);
-                $this->fail('Expected exception when creating index');
-            } catch (\Throwable $e) {
-                $this->assertInstanceOf(IndexException::class, $e);
-            }
-
-        } finally {
-            $database->deleteCollection($collUpdateNull);
-        }
-    }
-
     public function testSpatialDocOrder(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'test_spatial_order_axis';
         // Create collection first
-        $database->createCollection($collectionName);
+        $database->createCollection(new Collection(id: $collectionName));
 
         // Create spatial attributes using createAttribute method
-        $this->assertEquals(true, $database->createAttribute($collectionName, 'pointAttr', Database::VAR_POINT, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true));
+        $this->assertEquals(true, $database->createAttribute($collectionName, Attribute::point(key: 'pointAttr', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
 
         // Create test document
         $doc1 = new Document(
             [
                 '$id' => 'doc1',
                 'pointAttr' => [5.0, 5.5],
-                '$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())]
+                '$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())],
             ]
         );
         $database->createDocument($collectionName, $doc1);
 
         $result = $database->getDocument($collectionName, 'doc1');
-        $this->assertEquals($result->getAttribute('pointAttr')[0], 5.0);
-        $this->assertEquals($result->getAttribute('pointAttr')[1], 5.5);
+        $point = $result->getAttribute('pointAttr');
+        $this->assertIsArray($point);
+        $this->assertEquals($point[0], 5.0);
+        $this->assertEquals($point[1], 5.5);
         $database->deleteCollection($collectionName);
     }
 
-    public function testInvalidCoordinateDocuments(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = 'test_invalid_coord_';
-        try {
-            $database->createCollection($collectionName);
-
-            $database->createAttribute($collectionName, 'pointAttr', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collectionName, 'lineAttr', Database::VAR_LINESTRING, 0, true);
-            $database->createAttribute($collectionName, 'polyAttr', Database::VAR_POLYGON, 0, true);
-
-            $invalidDocs = [
-                // Invalid POINT (longitude > 180)
-                [
-                    '$id' => 'invalidDoc1',
-                    'pointAttr' => [200.0, 20.0],
-                    'lineAttr' => [[1.0, 2.0], [3.0, 4.0]],
-                    'polyAttr' => [
-                        [
-                            [0.0, 0.0],
-                            [0.0, 10.0],
-                            [10.0, 10.0],
-                            [10.0, 0.0],
-                            [0.0, 0.0]
-                        ]
-                    ]
-                ],
-                // Invalid POINT (latitude < -90)
-                [
-                    '$id' => 'invalidDoc2',
-                    'pointAttr' => [50.0, -100.0],
-                    'lineAttr' => [[1.0, 2.0], [3.0, 4.0]],
-                    'polyAttr' => [
-                        [
-                            [0.0, 0.0],
-                            [0.0, 10.0],
-                            [10.0, 10.0],
-                            [10.0, 0.0],
-                            [0.0, 0.0]
-                        ]
-                    ]
-                ],
-                // Invalid LINESTRING (point outside valid range)
-                [
-                    '$id' => 'invalidDoc3',
-                    'pointAttr' => [50.0, 20.0],
-                    'lineAttr' => [[1.0, 2.0], [300.0, 4.0]], // invalid longitude in line
-                    'polyAttr' => [
-                        [
-                            [0.0, 0.0],
-                            [0.0, 10.0],
-                            [10.0, 10.0],
-                            [10.0, 0.0],
-                            [0.0, 0.0]
-                        ]
-                    ]
-                ],
-                // Invalid POLYGON (point outside valid range)
-                [
-                    '$id' => 'invalidDoc4',
-                    'pointAttr' => [50.0, 20.0],
-                    'lineAttr' => [[1.0, 2.0], [3.0, 4.0]],
-                    'polyAttr' => [
-                        [
-                            [0.0, 0.0],
-                            [0.0, 10.0],
-                            [190.0, 10.0], // invalid longitude
-                            [10.0, 0.0],
-                            [0.0, 0.0]
-                        ]
-                    ]
-                ],
-            ];
-            foreach ($invalidDocs as $docData) {
-                $this->expectException(StructureException::class);
-                $docData['$permissions'] = [Permission::update(Role::any()), Permission::read(Role::any())];
-                $doc = new Document($docData);
-                $database->createDocument($collectionName, $doc);
-            }
-
-
-        } finally {
-            $database->deleteCollection($collectionName);
-        }
-    }
-
     public function testCreateSpatialColumnWithExistingData(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        if ($database->getAdapter()->getSupportForSpatialIndexNull()) {
+        if ($database->getAdapter()->supports(Capability::SpatialIndexNull)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if ($database->getAdapter()->getSupportForOptionalSpatialAttributeWithExistingRows()) {
+        if ($database->getAdapter()->supports(Capability::OptionalSpatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $col = 'spatial_col_existing_data';
         try {
-            $database->createCollection($col);
+            $database->createCollection(new Collection(id: $col));
 
-            $database->createAttribute($col, 'name', Database::VAR_STRING, 40, false);
-            $database->createDocument($col, new Document(['name' => 'test-doc','$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())]]));
+            $database->createAttribute($col, Attribute::string(key: 'name', size: 40));
+            $database->createDocument($col, new Document(['name' => 'test-doc', '$permissions' => [Permission::update(Role::any()), Permission::read(Role::any())]]));
             try {
-                $database->createAttribute($col, 'loc', Database::VAR_POINT, 0, true);
+                $database->createAttribute($col, Attribute::point(key: 'loc', required: true));
             } catch (\Throwable $e) {
                 $this->assertInstanceOf(StructureException::class, $e);
             }
@@ -2859,25 +2316,26 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter()->hasFeature(Feature\Spatial::class))) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $collectionName = 'test_spatial_wkt_conversion';
 
         try {
-            $database->createCollection($collectionName);
+            $database->createCollection(new Collection(id: $collectionName));
             // Use required=true for spatial attributes to support spatial indexes (MariaDB requires this)
-            $database->createAttribute($collectionName, 'location', Database::VAR_POINT, 0, true);
-            $database->createAttribute($collectionName, 'route', Database::VAR_LINESTRING, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true);
-            $database->createAttribute($collectionName, 'area', Database::VAR_POLYGON, 0, $database->getAdapter()->getSupportForSpatialIndexNull() ? false : true);
-            $database->createAttribute($collectionName, 'name', Database::VAR_STRING, 100, false);
+            $database->createAttribute($collectionName, Attribute::point(key: 'location', required: true));
+            $database->createAttribute($collectionName, Attribute::linestring(key: 'route', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true));
+            $database->createAttribute($collectionName, Attribute::polygon(key: 'area', required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true));
+            $database->createAttribute($collectionName, Attribute::string(key: 'name', size: 100));
 
             // Create indexes for spatial queries
-            $database->createIndex($collectionName, 'location_idx', Database::INDEX_SPATIAL, ['location']);
-            $database->createIndex($collectionName, 'route_idx', Database::INDEX_SPATIAL, ['route']);
-            $database->createIndex($collectionName, 'area_idx', Database::INDEX_SPATIAL, ['area']);
+            $database->createIndex($collectionName, Index::spatial(key: 'location_idx', attributes: ['location']));
+            $database->createIndex($collectionName, Index::spatial(key: 'route_idx', attributes: ['route']));
+            $database->createIndex($collectionName, Index::spatial(key: 'area_idx', attributes: ['area']));
 
             // Create initial document with spatial arrays
             $initialPoint = [10.0, 20.0];
@@ -2890,7 +2348,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
                 'location' => $initialPoint,
                 'route' => $initialLine,
                 'area' => $initialPolygon,
-                'name' => 'Original'
+                'name' => 'Original',
             ]));
 
             // Verify initial values
@@ -2907,7 +2365,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
                 'location' => $newPoint,
                 'route' => $newLine,
                 'area' => $newPolygon,
-                'name' => 'Updated'
+                'name' => 'Updated',
             ]));
 
             // Verify updated spatial values are correctly stored and retrieved
@@ -2924,7 +2382,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
 
             // Test spatial queries work with updated data
             $results = $database->find($collectionName, [
-                Query::equal('location', [$newPoint])
+                Query::equal('location', [$newPoint]),
             ]);
             $this->assertCount(1, $results, 'Should find document by exact point match');
             $this->assertEquals('spatial_doc', $results[0]->getId());
@@ -2932,7 +2390,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
             // Test mixed update (spatial + non-spatial attributes)
             $updated2 = $database->updateDocument($collectionName, 'spatial_doc', new Document([
                 'location' => [50.0, 60.0],
-                'name' => 'Mixed Update'
+                'name' => 'Mixed Update',
             ]));
             $this->assertEquals([50.0, 60.0], $updated2->getAttribute('location'));
             $this->assertEquals('Mixed Update', $updated2->getAttribute('name'));
diff --git a/tests/e2e/Adapter/Scopes/VectorTests.php b/tests/e2e/Adapter/Scopes/VectorTests.php
index 3d229c3e18..ab3de67906 100644
--- a/tests/e2e/Adapter/Scopes/VectorTests.php
+++ b/tests/e2e/Adapter/Scopes/VectorTests.php
@@ -2,13 +2,18 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Relationship;
+use Utopia\Query\Schema\ColumnType;
 
 trait VectorTests
 {
@@ -17,125 +22,85 @@ public function testVectorAttributes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Test that vector attributes can only be created on PostgreSQL
-        $database->createCollection('vectorCollection');
+        $database->createCollection(new Collection(id: 'vectorCollection'));
 
         // Create a vector attribute with 3 dimensions
-        $database->createAttribute('vectorCollection', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createAttribute('vectorCollection', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create a vector attribute with 128 dimensions
-        $database->createAttribute('vectorCollection', 'large_embedding', Database::VAR_VECTOR, 128, false, null);
+        $database->createAttribute('vectorCollection', Attribute::vector(key: 'large_embedding', size: 128));
 
         // Verify the attributes were created
         $collection = $database->getCollection('vectorCollection');
-        $attributes = $collection->getAttribute('attributes');
+        $attributes = $collection->attributes;
 
         $embeddingAttr = null;
         $largeEmbeddingAttr = null;
 
         foreach ($attributes as $attr) {
-            if ($attr['key'] === 'embedding') {
+            if ($attr->getAttribute('key') === 'embedding') {
                 $embeddingAttr = $attr;
-            } elseif ($attr['key'] === 'large_embedding') {
+            } elseif ($attr->getAttribute('key') === 'large_embedding') {
                 $largeEmbeddingAttr = $attr;
             }
         }
 
-        $this->assertNotNull($embeddingAttr);
-        $this->assertNotNull($largeEmbeddingAttr);
-        $this->assertEquals(Database::VAR_VECTOR, $embeddingAttr['type']);
-        $this->assertEquals(3, $embeddingAttr['size']);
-        $this->assertEquals(Database::VAR_VECTOR, $largeEmbeddingAttr['type']);
-        $this->assertEquals(128, $largeEmbeddingAttr['size']);
+        $this->assertInstanceOf(Document::class, $embeddingAttr);
+        $this->assertInstanceOf(Document::class, $largeEmbeddingAttr);
+        $this->assertEquals(ColumnType::Vector->value, $embeddingAttr->getAttribute('type'));
+        $this->assertEquals(3, $embeddingAttr->getAttribute('size'));
+        $this->assertEquals(ColumnType::Vector->value, $largeEmbeddingAttr->getAttribute('type'));
+        $this->assertEquals(128, $largeEmbeddingAttr->getAttribute('size'));
 
         // Cleanup
         $database->deleteCollection('vectorCollection');
     }
 
-    public function testVectorInvalidDimensions(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorErrorCollection');
-
-        // Test invalid dimensions
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Vector dimensions must be a positive integer');
-        $database->createAttribute('vectorErrorCollection', 'bad_embedding', Database::VAR_VECTOR, 0, true);
-
-        // Cleanup
-        $database->deleteCollection('vectorErrorCollection');
-    }
-
-    public function testVectorTooManyDimensions(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorLimitCollection');
-
-        // Test too many dimensions (pgvector limit is 16000)
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Vector dimensions cannot exceed 16000');
-        $database->createAttribute('vectorLimitCollection', 'huge_embedding', Database::VAR_VECTOR, 16001, true);
-
-        // Cleanup
-        $database->deleteCollection('vectorLimitCollection');
-    }
-
     public function testVectorDocuments(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorDocuments');
-        $database->createAttribute('vectorDocuments', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorDocuments', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorDocuments'));
+        $database->createAttribute('vectorDocuments', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorDocuments', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents with vector data
         $doc1 = $database->createDocument('vectorDocuments', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Document 1',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $doc2 = $database->createDocument('vectorDocuments', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Document 2',
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         $doc3 = $database->createDocument('vectorDocuments', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Document 3',
-            'embedding' => [0.0, 0.0, 1.0]
+            'embedding' => [0.0, 0.0, 1.0],
         ]));
 
         $this->assertNotEmpty($doc1->getId());
@@ -155,38 +120,39 @@ public function testVectorQueries(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorQueries');
-        $database->createAttribute('vectorQueries', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorQueries', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorQueries'));
+        $database->createAttribute('vectorQueries', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorQueries', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create test documents with read permissions
         $doc1 = $database->createDocument('vectorQueries', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Test 1',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $doc2 = $database->createDocument('vectorQueries', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Test 2',
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         $doc3 = $database->createDocument('vectorQueries', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Test 3',
-            'embedding' => [0.5, 0.5, 0.0]
+            'embedding' => [0.5, 0.5, 0.0],
         ]));
 
         // Verify documents were created
@@ -196,12 +162,12 @@ public function testVectorQueries(): void
 
         // Test without vector queries first
         $allDocs = $database->find('vectorQueries');
-        $this->assertCount(3, $allDocs, "Should have 3 documents in collection");
+        $this->assertCount(3, $allDocs, 'Should have 3 documents in collection');
 
         // Test vector dot product query
         $results = $database->find('vectorQueries', [
             Query::vectorDot('embedding', [1.0, 0.0, 0.0]),
-            Query::orderAsc('$id')
+            Query::orderAsc('$id'),
         ]);
 
         $this->assertCount(3, $results);
@@ -209,7 +175,7 @@ public function testVectorQueries(): void
         // Test vector cosine distance query
         $results = $database->find('vectorQueries', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::orderAsc('$id')
+            Query::orderAsc('$id'),
         ]);
 
         $this->assertCount(3, $results);
@@ -217,7 +183,7 @@ public function testVectorQueries(): void
         // Test vector euclidean distance query
         $results = $database->find('vectorQueries', [
             Query::vectorEuclidean('embedding', [1.0, 0.0, 0.0]),
-            Query::orderAsc('$id')
+            Query::orderAsc('$id'),
         ]);
 
         $this->assertCount(3, $results);
@@ -225,7 +191,7 @@ public function testVectorQueries(): void
         // Test vector queries with limit - should return only top results
         $results = $database->find('vectorQueries', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(2)
+            Query::limit(2),
         ]);
 
         $this->assertCount(2, $results);
@@ -235,7 +201,7 @@ public function testVectorQueries(): void
         // Test vector query with limit of 1
         $results = $database->find('vectorQueries', [
             Query::vectorDot('embedding', [0.0, 1.0, 0.0]),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertCount(1, $results);
@@ -244,7 +210,7 @@ public function testVectorQueries(): void
         // Test vector query combined with other filters
         $results = $database->find('vectorQueries', [
             Query::vectorCosine('embedding', [0.5, 0.5, 0.0]),
-            Query::notEqual('name', 'Test 1')
+            Query::notEqual('name', 'Test 1'),
         ]);
 
         $this->assertCount(2, $results);
@@ -256,7 +222,7 @@ public function testVectorQueries(): void
         // Test vector query with specific name filter
         $results = $database->find('vectorQueries', [
             Query::vectorEuclidean('embedding', [0.7, 0.7, 0.0]),
-            Query::equal('name', ['Test 3'])
+            Query::equal('name', ['Test 3']),
         ]);
 
         $this->assertCount(1, $results);
@@ -266,7 +232,7 @@ public function testVectorQueries(): void
         $results = $database->find('vectorQueries', [
             Query::vectorDot('embedding', [0.5, 0.5, 0.0]),
             Query::limit(2),
-            Query::offset(1)
+            Query::offset(1),
         ]);
 
         $this->assertCount(2, $results);
@@ -276,7 +242,7 @@ public function testVectorQueries(): void
         $results = $database->find('vectorQueries', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::equal('name', ['Test 2']),
-            Query::equal('name', ['Test 3'])  // Impossible condition
+            Query::equal('name', ['Test 3']),  // Impossible condition
         ]);
 
         $this->assertCount(0, $results);
@@ -286,7 +252,7 @@ public function testVectorQueries(): void
         $results = $database->find('vectorQueries', [
             Query::vectorDot('embedding', [0.4, 0.6, 0.0]),
             Query::orderDesc('name'),
-            Query::limit(2)
+            Query::limit(2),
         ]);
 
         $this->assertCount(2, $results);
@@ -302,234 +268,55 @@ public function testVectorQueries(): void
         $database->deleteCollection('vectorQueries');
     }
 
-    public function testVectorDistance(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorDistance');
-        $database->createAttribute('vectorDistance', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorDistance', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        $vectors = [
-            'identical' => [1.0, 0.0, 0.0],
-            'scaled' => [2.0, 0.0, 0.0],
-            'orthogonal' => [0.0, 1.0, 0.0],
-            'opposite' => [-1.0, 0.0, 0.0],
-        ];
-
-        foreach ($vectors as $name => $embedding) {
-            $database->createDocument('vectorDistance', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'name' => $name,
-                'embedding' => $embedding,
-            ]));
-        }
-
-        $target = [1.0, 0.0, 0.0];
-
-        $results = $database->find('vectorDistance', [
-            Query::vectorCosine('embedding', $target)
-        ]);
-
-        $this->assertCount(4, $results);
-
-        $cosine = [];
-        foreach ($results as $result) {
-            $distance = $result->getAttribute(Database::VECTOR_DISTANCE);
-
-            $this->assertIsFloat($distance, "Cosine distance for '{$result->getAttribute('name')}' must be a float");
-
-            $cosine[$result->getAttribute('name')] = $distance;
-        }
-
-        // Cosine distance is 1 - cosine similarity, so magnitude is irrelevant
-        $this->assertEqualsWithDelta(0.0, $cosine['identical'], 0.000001, 'Identical vector must have zero cosine distance');
-        $this->assertEqualsWithDelta(0.0, $cosine['scaled'], 0.000001, 'Cosine distance must ignore magnitude');
-        $this->assertEqualsWithDelta(1.0, $cosine['orthogonal'], 0.000001, 'Orthogonal vector must have cosine distance of 1');
-        $this->assertEqualsWithDelta(2.0, $cosine['opposite'], 0.000001, 'Opposite vector must have cosine distance of 2');
-
-        // The returned distance must agree with the order the rows came back in,
-        // otherwise a caller ranking by the number would disagree with the database
-        $distances = \array_map(
-            fn (Document $result) => $result->getAttribute(Database::VECTOR_DISTANCE),
-            $results
-        );
-
-        $sorted = $distances;
-        \sort($sorted);
-        $this->assertSame($sorted, $distances, 'Results must be returned in ascending distance order');
-
-        // Cosine similarity, which is what a caller displays as a relevance score
-        $this->assertEqualsWithDelta(1.0, 1 - $cosine['identical'], 0.000001);
-        $this->assertEqualsWithDelta(0.0, 1 - $cosine['orthogonal'], 0.000001);
-        $this->assertEqualsWithDelta(-1.0, 1 - $cosine['opposite'], 0.000001);
-
-        $results = $database->find('vectorDistance', [
-            Query::vectorEuclidean('embedding', $target)
-        ]);
-
-        $euclidean = [];
-        foreach ($results as $result) {
-            $euclidean[$result->getAttribute('name')] = $result->getAttribute(Database::VECTOR_DISTANCE);
-        }
-
-        $this->assertEqualsWithDelta(0.0, $euclidean['identical'], 0.000001, 'Identical vector must have zero euclidean distance');
-        $this->assertEqualsWithDelta(1.0, $euclidean['scaled'], 0.000001, 'Euclidean distance must account for magnitude');
-        $this->assertEqualsWithDelta(\sqrt(2), $euclidean['orthogonal'], 0.000001);
-        $this->assertEqualsWithDelta(2.0, $euclidean['opposite'], 0.000001);
-
-        // The dot product operator returns the negative inner product so that
-        // ascending order still means most similar first
-        $results = $database->find('vectorDistance', [
-            Query::vectorDot('embedding', $target)
-        ]);
-
-        $dot = [];
-        foreach ($results as $result) {
-            $dot[$result->getAttribute('name')] = $result->getAttribute(Database::VECTOR_DISTANCE);
-        }
-
-        $this->assertEqualsWithDelta(-1.0, $dot['identical'], 0.000001);
-        $this->assertEqualsWithDelta(-2.0, $dot['scaled'], 0.000001);
-        $this->assertEqualsWithDelta(0.0, $dot['orthogonal'], 0.000001);
-        $this->assertEqualsWithDelta(1.0, $dot['opposite'], 0.000001);
-
-        // A distance is only meaningful relative to a query vector, so a plain
-        // find must not carry one
-        $results = $database->find('vectorDistance');
-
-        $this->assertCount(4, $results);
-        foreach ($results as $result) {
-            $this->assertNull(
-                $result->getAttribute(Database::VECTOR_DISTANCE),
-                'A find without a vector query must not return a distance'
-            );
-        }
-
-        // Selecting a subset of attributes builds a different projection
-        $results = $database->find('vectorDistance', [
-            Query::select(['name']),
-            Query::vectorCosine('embedding', $target),
-            Query::limit(1),
-        ]);
-
-        $this->assertCount(1, $results);
-        $this->assertSame('identical', $results[0]->getAttribute('name'));
-        $this->assertEqualsWithDelta(0.0, $results[0]->getAttribute(Database::VECTOR_DISTANCE), 0.000001);
-
-        // Cosine distance to a zero vector divides by a zero magnitude, so the engine answers
-        // NaN. That has no honest float representation and must not read back as 0.0, which
-        // would claim the pair is identical
-        $database->createDocument('vectorDistance', new Document([
-            '$permissions' => [
-                Permission::read(Role::any())
-            ],
-            'name' => 'zero',
-            'embedding' => [0.0, 0.0, 0.0],
-        ]));
-
-        $results = $database->find('vectorDistance', [
-            Query::vectorCosine('embedding', $target)
-        ]);
-
-        $this->assertCount(5, $results);
-
-        $zero = null;
-        foreach ($results as $result) {
-            if ($result->getAttribute('name') === 'zero') {
-                $zero = $result;
-            }
-        }
-
-        $this->assertNotNull($zero, 'The zero vector must still be returned');
-        $this->assertNull(
-            $zero->getAttribute(Database::VECTOR_DISTANCE),
-            'An undefined distance must be null, not a number'
-        );
-
-        $database->deleteCollection('vectorDistance');
-    }
-
-    public function testVectorQueryValidation(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorValidation');
-        $database->createAttribute('vectorValidation', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorValidation', 'name', Database::VAR_STRING, 255, true);
-
-        // Test that vector queries fail on non-vector attributes
-        $this->expectException(DatabaseException::class);
-        $database->find('vectorValidation', [
-            Query::vectorDot('name', [1.0, 0.0, 0.0])
-        ]);
-
-        // Cleanup
-        $database->deleteCollection('vectorValidation');
-    }
-
     public function testVectorIndexes(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorIndexes');
-        $database->createAttribute('vectorIndexes', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorIndexes'));
+        $database->createAttribute('vectorIndexes', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create different types of vector indexes
         // Euclidean distance index (L2 distance)
-        $database->createIndex('vectorIndexes', 'embedding_euclidean', Database::INDEX_HNSW_EUCLIDEAN, ['embedding']);
+        $database->createIndex('vectorIndexes', Index::hnswEuclidean(key: 'embedding_euclidean', attributes: ['embedding']));
 
         // Cosine distance index
-        $database->createIndex('vectorIndexes', 'embedding_cosine', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorIndexes', Index::hnswCosine(key: 'embedding_cosine', attributes: ['embedding']));
 
         // Inner product (dot product) index
-        $database->createIndex('vectorIndexes', 'embedding_dot', Database::INDEX_HNSW_DOT, ['embedding']);
+        $database->createIndex('vectorIndexes', Index::hnswDot(key: 'embedding_dot', attributes: ['embedding']));
 
         // Verify indexes were created
         $collection = $database->getCollection('vectorIndexes');
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
 
         $this->assertCount(3, $indexes);
 
         // Test that queries work with indexes
         $database->createDocument('vectorIndexes', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $database->createDocument('vectorIndexes', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         // Query should use the appropriate index based on the operator
         $results = $database->find('vectorIndexes', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertCount(1, $results);
@@ -538,96 +325,26 @@ public function testVectorIndexes(): void
         $database->deleteCollection('vectorIndexes');
     }
 
-    public function testVectorDimensionMismatch(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorDimMismatch');
-        $database->createAttribute('vectorDimMismatch', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test creating document with wrong dimension count
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessageMatches('/must be an array of 3 numeric values/');
-
-        $database->createDocument('vectorDimMismatch', new Document([
-            '$permissions' => [
-                Permission::read(Role::any())
-            ],
-            'embedding' => [1.0, 0.0] // Only 2 dimensions, expects 3
-        ]));
-
-        // Cleanup
-        $database->deleteCollection('vectorDimMismatch');
-    }
-
-    public function testVectorWithInvalidDataTypes(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorInvalidTypes');
-        $database->createAttribute('vectorInvalidTypes', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with string values in vector
-        try {
-            $database->createDocument('vectorInvalidTypes', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => ['one', 'two', 'three']
-            ]));
-            $this->fail('Should have thrown exception for non-numeric vector values');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric values', strtolower($e->getMessage()));
-        }
-
-        // Test with mixed types
-        try {
-            $database->createDocument('vectorInvalidTypes', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [1.0, 'two', 3.0]
-            ]));
-            $this->fail('Should have thrown exception for mixed type vector values');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric values', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorInvalidTypes');
-    }
-
     public function testVectorWithNullAndEmpty(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorNullEmpty');
-        $database->createAttribute('vectorNullEmpty', 'embedding', Database::VAR_VECTOR, 3, false); // Not required
+        $database->createCollection(new Collection(id: 'vectorNullEmpty'));
+        $database->createAttribute('vectorNullEmpty', Attribute::vector(key: 'embedding', size: 3)); // Not required
 
         // Test with null vector (should work for non-required attribute)
         $doc1 = $database->createDocument('vectorNullEmpty', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => null
+            'embedding' => null,
         ]));
 
         $this->assertNull($doc1->getAttribute('embedding'));
@@ -636,9 +353,9 @@ public function testVectorWithNullAndEmpty(): void
         try {
             $database->createDocument('vectorNullEmpty', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => []
+                'embedding' => [],
             ]));
             $this->fail('Should have thrown exception for empty vector');
         } catch (DatabaseException $e) {
@@ -654,14 +371,15 @@ public function testLargeVectors(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Test with maximum allowed dimensions (16000 for pgvector)
-        $database->createCollection('vectorLarge');
-        $database->createAttribute('vectorLarge', 'embedding', Database::VAR_VECTOR, 1536, true); // Common embedding size
+        $database->createCollection(new Collection(id: 'vectorLarge'));
+        $database->createAttribute('vectorLarge', Attribute::vector(key: 'embedding', size: 1536, required: true)); // Common embedding size
 
         // Create a large vector
         $largeVector = array_fill(0, 1536, 0.1);
@@ -669,20 +387,22 @@ public function testLargeVectors(): void
 
         $doc = $database->createDocument('vectorLarge', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => $largeVector
+            'embedding' => $largeVector,
         ]));
 
-        $this->assertCount(1536, $doc->getAttribute('embedding'));
-        $this->assertEquals(1.0, $doc->getAttribute('embedding')[0]);
+        $embedding = $doc->getAttribute('embedding');
+        $this->assertIsArray($embedding);
+        $this->assertCount(1536, $embedding);
+        $this->assertEquals(1.0, $embedding[0]);
 
         // Test vector search on large vectors
         $searchVector = array_fill(0, 1536, 0.0);
         $searchVector[0] = 1.0;
 
         $results = $database->find('vectorLarge', [
-            Query::vectorCosine('embedding', $searchVector)
+            Query::vectorCosine('embedding', $searchVector),
         ]);
 
         $this->assertCount(1, $results);
@@ -696,35 +416,36 @@ public function testVectorUpdates(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorUpdates');
-        $database->createAttribute('vectorUpdates', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorUpdates'));
+        $database->createAttribute('vectorUpdates', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create initial document
         $doc = $database->createDocument('vectorUpdates', new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
+                Permission::update(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $this->assertEquals([1.0, 0.0, 0.0], $doc->getAttribute('embedding'));
 
         // Update the vector
         $updated = $database->updateDocument('vectorUpdates', $doc->getId(), new Document([
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         $this->assertEquals([0.0, 1.0, 0.0], $updated->getAttribute('embedding'));
 
         // Test partial update (should replace entire vector)
         $updated2 = $database->updateDocument('vectorUpdates', $doc->getId(), new Document([
-            'embedding' => [0.5, 0.5, 0.5]
+            'embedding' => [0.5, 0.5, 0.5],
         ]));
 
         $this->assertEquals([0.5, 0.5, 0.5], $updated2->getAttribute('embedding'));
@@ -738,38 +459,39 @@ public function testMultipleVectorAttributes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('multiVector');
-        $database->createAttribute('multiVector', 'embedding1', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('multiVector', 'embedding2', Database::VAR_VECTOR, 5, true);
-        $database->createAttribute('multiVector', 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'multiVector'));
+        $database->createAttribute('multiVector', Attribute::vector(key: 'embedding1', size: 3, required: true));
+        $database->createAttribute('multiVector', Attribute::vector(key: 'embedding2', size: 5, required: true));
+        $database->createAttribute('multiVector', Attribute::string(key: 'name', required: true));
 
         // Create documents with multiple vector attributes
         $doc1 = $database->createDocument('multiVector', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Doc 1',
             'embedding1' => [1.0, 0.0, 0.0],
-            'embedding2' => [1.0, 0.0, 0.0, 0.0, 0.0]
+            'embedding2' => [1.0, 0.0, 0.0, 0.0, 0.0],
         ]));
 
         $doc2 = $database->createDocument('multiVector', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Doc 2',
             'embedding1' => [0.0, 1.0, 0.0],
-            'embedding2' => [0.0, 1.0, 0.0, 0.0, 0.0]
+            'embedding2' => [0.0, 1.0, 0.0, 0.0, 0.0],
         ]));
 
         // Query by first vector
         $results = $database->find('multiVector', [
-            Query::vectorCosine('embedding1', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding1', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -777,7 +499,7 @@ public function testMultipleVectorAttributes(): void
 
         // Query by second vector
         $results = $database->find('multiVector', [
-            Query::vectorCosine('embedding2', [0.0, 1.0, 0.0, 0.0, 0.0])
+            Query::vectorCosine('embedding2', [0.0, 1.0, 0.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -792,29 +514,40 @@ public function testVectorQueriesWithPagination(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorPagination');
-        $database->createAttribute('vectorPagination', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorPagination', 'index', Database::VAR_INTEGER, 0, true);
+        $database->createCollection(new Collection(id: 'vectorPagination'));
+        $database->createAttribute('vectorPagination', Attribute::vector(key: 'embedding', size: 3));
+        $database->createAttribute('vectorPagination', Attribute::integer(key: 'index', required: true));
 
-        // Create 10 documents
-        for ($i = 0; $i < 10; $i++) {
+        // Insert documents in an order deliberately unrelated to vector rank.
+        // Cursor pagination must continue from distance + sequence, not from
+        // sequence alone.
+        $ranks = [6, 1, 8, 3, 0, 9, 4, 2, 7, 5];
+        foreach ($ranks as $rank) {
             $database->createDocument('vectorPagination', new Document([
+                '$id' => "rank-{$rank}",
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'index' => $i,
+                'index' => $rank,
                 'embedding' => [
-                    cos($i * M_PI / 10),
-                    sin($i * M_PI / 10),
-                    0.0
-                ]
+                    cos($rank * M_PI / 10),
+                    sin($rank * M_PI / 10),
+                    0.0,
+                ],
             ]));
         }
+        $database->createDocument('vectorPagination', new Document([
+            '$id' => 'rank-null',
+            '$permissions' => [Permission::read(Role::any())],
+            'index' => -1,
+            'embedding' => null,
+        ]));
 
         // Test pagination with vector queries
         $searchVector = [1.0, 0.0, 0.0];
@@ -823,7 +556,7 @@ public function testVectorQueriesWithPagination(): void
         $page1 = $database->find('vectorPagination', [
             Query::vectorCosine('embedding', $searchVector),
             Query::limit(3),
-            Query::offset(0)
+            Query::offset(0),
         ]);
 
         $this->assertCount(3, $page1);
@@ -832,7 +565,7 @@ public function testVectorQueriesWithPagination(): void
         $page2 = $database->find('vectorPagination', [
             Query::vectorCosine('embedding', $searchVector),
             Query::limit(3),
-            Query::offset(3)
+            Query::offset(3),
         ]);
 
         $this->assertCount(3, $page2);
@@ -841,11 +574,12 @@ public function testVectorQueriesWithPagination(): void
         $page1Ids = array_map(fn ($doc) => $doc->getId(), $page1);
         $page2Ids = array_map(fn ($doc) => $doc->getId(), $page2);
         $this->assertEmpty(array_intersect($page1Ids, $page2Ids));
+        $this->assertNotContains('rank-null', [...$page1Ids, ...$page2Ids]);
 
         // Test with cursor pagination
         $firstBatch = $database->find('vectorPagination', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(5, $firstBatch);
@@ -854,11 +588,18 @@ public function testVectorQueriesWithPagination(): void
         $nextBatch = $database->find('vectorPagination', [
             Query::vectorCosine('embedding', $searchVector),
             Query::cursorAfter($lastDoc),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(5, $nextBatch);
         $this->assertNotEquals($lastDoc->getId(), $nextBatch[0]->getId());
+        $cursorIds = array_map(fn ($document) => $document->getId(), [...$firstBatch, ...$nextBatch]);
+        $this->assertCount(10, array_unique($cursorIds));
+        $this->assertNotContains('rank-null', $cursorIds);
+        $this->assertSame(
+            array_map(fn (int $rank): string => "rank-{$rank}", range(0, 9)),
+            $cursorIds,
+        );
 
         // Cleanup
         $database->deleteCollection('vectorPagination');
@@ -869,18 +610,19 @@ public function testCombinedVectorAndTextSearch(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorTextSearch');
-        $database->createAttribute('vectorTextSearch', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorTextSearch', 'category', Database::VAR_STRING, 50, true);
-        $database->createAttribute('vectorTextSearch', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorTextSearch'));
+        $database->createAttribute('vectorTextSearch', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('vectorTextSearch', Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute('vectorTextSearch', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create fulltext index for title
-        $database->createIndex('vectorTextSearch', 'title_fulltext', Database::INDEX_FULLTEXT, ['title']);
+        $database->createIndex('vectorTextSearch', Index::fullText(key: 'title_fulltext', attributes: ['title']));
 
         // Create test documents
         $docs = [
@@ -894,9 +636,9 @@ public function testCombinedVectorAndTextSearch(): void
         foreach ($docs as $doc) {
             $database->createDocument('vectorTextSearch', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                ...$doc
+                ...$doc,
             ]));
         }
 
@@ -904,7 +646,7 @@ public function testCombinedVectorAndTextSearch(): void
         $results = $database->find('vectorTextSearch', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::equal('category', ['AI']),
-            Query::limit(2)
+            Query::limit(2),
         ]);
 
         $this->assertCount(2, $results);
@@ -915,19 +657,21 @@ public function testCombinedVectorAndTextSearch(): void
         $results = $database->find('vectorTextSearch', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::search('title', 'Learning'),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(2, $results);
         foreach ($results as $result) {
-            $this->assertStringContainsString('Learning', $result->getAttribute('title'));
+            $title = $result->getAttribute('title');
+            $this->assertIsString($title);
+            $this->assertStringContainsString('Learning', $title);
         }
 
         // Complex query with multiple filters
         $results = $database->find('vectorTextSearch', [
             Query::vectorEuclidean('embedding', [0.5, 0.5, 0.0]),
             Query::notEqual('category', ['Web']),
-            Query::limit(3)
+            Query::limit(3),
         ]);
 
         $this->assertCount(3, $results);
@@ -944,57 +688,58 @@ public function testVectorSpecialFloatValues(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorSpecialFloats');
-        $database->createAttribute('vectorSpecialFloats', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorSpecialFloats'));
+        $database->createAttribute('vectorSpecialFloats', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Test with very small values (near zero)
         $doc1 = $database->createDocument('vectorSpecialFloats', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1e-10, 1e-10, 1e-10]
+            'embedding' => [1e-10, 1e-10, 1e-10],
         ]));
 
-        $this->assertNotNull($doc1->getId());
+        $this->assertNotSame('', $doc1->getId());
 
         // Test with very large values
         $doc2 = $database->createDocument('vectorSpecialFloats', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1e10, 1e10, 1e10]
+            'embedding' => [1e10, 1e10, 1e10],
         ]));
 
-        $this->assertNotNull($doc2->getId());
+        $this->assertNotSame('', $doc2->getId());
 
         // Test with negative values
         $doc3 = $database->createDocument('vectorSpecialFloats', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [-1.0, -0.5, -0.1]
+            'embedding' => [-1.0, -0.5, -0.1],
         ]));
 
-        $this->assertNotNull($doc3->getId());
+        $this->assertNotSame('', $doc3->getId());
 
         // Test with mixed sign values
         $doc4 = $database->createDocument('vectorSpecialFloats', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [-1.0, 0.0, 1.0]
+            'embedding' => [-1.0, 0.0, 1.0],
         ]));
 
-        $this->assertNotNull($doc4->getId());
+        $this->assertNotSame('', $doc4->getId());
 
         // Query with negative vector
         $results = $database->find('vectorSpecialFloats', [
-            Query::vectorCosine('embedding', [-1.0, -1.0, -1.0])
+            Query::vectorCosine('embedding', [-1.0, -1.0, -1.0]),
         ]);
 
         $this->assertGreaterThan(0, count($results));
@@ -1008,14 +753,15 @@ public function testVectorIndexPerformance(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorPerf');
-        $database->createAttribute('vectorPerf', 'embedding', Database::VAR_VECTOR, 128, true);
-        $database->createAttribute('vectorPerf', 'name', Database::VAR_STRING, 255, true);
+        $database->createCollection(new Collection(id: 'vectorPerf'));
+        $database->createAttribute('vectorPerf', Attribute::vector(key: 'embedding', size: 128, required: true));
+        $database->createAttribute('vectorPerf', Attribute::string(key: 'name', required: true));
 
         // Create documents
         $numDocs = 100;
@@ -1027,10 +773,10 @@ public function testVectorIndexPerformance(): void
 
             $database->createDocument('vectorPerf', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'name' => "Doc $i",
-                'embedding' => $vector
+                'embedding' => $vector,
             ]));
         }
 
@@ -1040,20 +786,20 @@ public function testVectorIndexPerformance(): void
         $startTime = microtime(true);
         $results1 = $database->find('vectorPerf', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(10)
+            Query::limit(10),
         ]);
         $timeWithoutIndex = microtime(true) - $startTime;
 
         $this->assertCount(10, $results1);
 
         // Create HNSW index
-        $database->createIndex('vectorPerf', 'embedding_hnsw', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorPerf', Index::hnswCosine(key: 'embedding_hnsw', attributes: ['embedding']));
 
         // Query with index (should be faster for larger datasets)
         $startTime = microtime(true);
         $results2 = $database->find('vectorPerf', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(10)
+            Query::limit(10),
         ]);
         $timeWithIndex = microtime(true) - $startTime;
 
@@ -1069,83 +815,38 @@ public function testVectorIndexPerformance(): void
         $database->deleteCollection('vectorPerf');
     }
 
-    public function testVectorQueryValidationExtended(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorValidation2');
-        $database->createAttribute('vectorValidation2', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorValidation2', 'text', Database::VAR_STRING, 255, true);
-
-        $database->createDocument('vectorValidation2', new Document([
-            '$permissions' => [
-                Permission::read(Role::any())
-            ],
-            'text' => 'Test',
-            'embedding' => [1.0, 0.0, 0.0]
-        ]));
-
-        // Test vector query with wrong dimension count
-        try {
-            $database->find('vectorValidation2', [
-                Query::vectorCosine('embedding', [1.0, 0.0]) // Wrong dimension
-            ]);
-            $this->fail('Should have thrown exception for dimension mismatch');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('elements', strtolower($e->getMessage()));
-        }
-
-        // Test vector query on non-vector attribute
-        try {
-            $database->find('vectorValidation2', [
-                Query::vectorCosine('text', [1.0, 0.0, 0.0])
-            ]);
-            $this->fail('Should have thrown exception for non-vector attribute');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('vector', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorValidation2');
-    }
-
     public function testVectorNormalization(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorNorm');
-        $database->createAttribute('vectorNorm', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorNorm'));
+        $database->createAttribute('vectorNorm', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents with normalized and non-normalized vectors
         $doc1 = $database->createDocument('vectorNorm', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0] // Already normalized
+            'embedding' => [1.0, 0.0, 0.0], // Already normalized
         ]));
 
         $doc2 = $database->createDocument('vectorNorm', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [3.0, 4.0, 0.0] // Not normalized (magnitude = 5)
+            'embedding' => [3.0, 4.0, 0.0], // Not normalized (magnitude = 5)
         ]));
 
         // Cosine similarity should work regardless of normalization
         $results = $database->find('vectorNorm', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -1163,238 +864,74 @@ public function testVectorWithInfinityValues(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorInfinity');
-        $database->createAttribute('vectorInfinity', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorInfinity'));
+        $database->createAttribute('vectorInfinity', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Test with INF value - should fail
         try {
             $database->createDocument('vectorInfinity', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => [INF, 0.0, 0.0]
+                'embedding' => [INF, 0.0, 0.0],
             ]));
             $this->fail('Should have thrown exception for INF value');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Test with -INF value - should fail
-        try {
-            $database->createDocument('vectorInfinity', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [-INF, 0.0, 0.0]
-            ]));
-            $this->fail('Should have thrown exception for -INF value');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorInfinity');
-    }
-
-    public function testVectorWithNaNValues(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorNaN');
-        $database->createAttribute('vectorNaN', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with NaN value - should fail
-        try {
-            $database->createDocument('vectorNaN', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [NAN, 0.0, 0.0]
-            ]));
-            $this->fail('Should have thrown exception for NaN value');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorNaN');
-    }
-
-    public function testVectorWithAssociativeArray(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorAssoc');
-        $database->createAttribute('vectorAssoc', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with associative array - should fail
-        try {
-            $database->createDocument('vectorAssoc', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => ['x' => 1.0, 'y' => 0.0, 'z' => 0.0]
-            ]));
-            $this->fail('Should have thrown exception for associative array');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorAssoc');
-    }
-
-    public function testVectorWithSparseArray(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorSparse');
-        $database->createAttribute('vectorSparse', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with sparse array (missing indexes) - should fail
-        try {
-            $vector = [];
-            $vector[0] = 1.0;
-            $vector[2] = 1.0; // Skip index 1
-            $database->createDocument('vectorSparse', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => $vector
-            ]));
-            $this->fail('Should have thrown exception for sparse array');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorSparse');
-    }
-
-    public function testVectorWithNestedArrays(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorNested');
-        $database->createAttribute('vectorNested', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with nested array - should fail
-        try {
-            $database->createDocument('vectorNested', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [[1.0], [0.0], [0.0]]
-            ]));
-            $this->fail('Should have thrown exception for nested array');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorNested');
-    }
-
-    public function testVectorWithBooleansInArray(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
         }
 
-        $database->createCollection('vectorBooleans');
-        $database->createAttribute('vectorBooleans', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with boolean values - should fail
+        // Test with -INF value - should fail
         try {
-            $database->createDocument('vectorBooleans', new Document([
+            $database->createDocument('vectorInfinity', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => [true, false, true]
+                'embedding' => [-INF, 0.0, 0.0],
             ]));
-            $this->fail('Should have thrown exception for boolean values');
+            $this->fail('Should have thrown exception for -INF value');
         } catch (DatabaseException $e) {
             $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
         }
 
         // Cleanup
-        $database->deleteCollection('vectorBooleans');
+        $database->deleteCollection('vectorInfinity');
     }
 
-    public function testVectorWithStringNumbers(): void
+    public function testVectorWithNaNValues(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorStringNums');
-        $database->createAttribute('vectorStringNums', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with numeric strings - should fail (strict validation)
-        try {
-            $database->createDocument('vectorStringNums', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => ['1.0', '2.0', '3.0']
-            ]));
-            $this->fail('Should have thrown exception for string numbers');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
+        $database->createCollection(new Collection(id: 'vectorNaN'));
+        $database->createAttribute('vectorNaN', Attribute::vector(key: 'embedding', size: 3, required: true));
 
-        // Test with strings containing spaces
+        // Test with NaN value - should fail
         try {
-            $database->createDocument('vectorStringNums', new Document([
+            $database->createDocument('vectorNaN', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => [' 1.0 ', '2.0', '3.0']
+                'embedding' => [NAN, 0.0, 0.0],
             ]));
-            $this->fail('Should have thrown exception for string numbers with spaces');
+            $this->fail('Should have thrown exception for NaN value');
         } catch (DatabaseException $e) {
             $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
         }
 
         // Cleanup
-        $database->deleteCollection('vectorStringNums');
+        $database->deleteCollection('vectorNaN');
     }
 
     public function testVectorWithRelationships(): void
@@ -1402,58 +939,65 @@ public function testVectorWithRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create parent collection with vectors
-        $database->createCollection('vectorParent');
-        $database->createAttribute('vectorParent', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorParent', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorParent'));
+        $database->createAttribute('vectorParent', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorParent', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create child collection
-        $database->createCollection('vectorChild');
-        $database->createAttribute('vectorChild', 'title', Database::VAR_STRING, 255, true);
-        $database->createRelationship('vectorChild', 'vectorParent', Database::RELATION_MANY_TO_ONE, true, 'parent', 'children');
+        $database->createCollection(new Collection(id: 'vectorChild'));
+        $database->createAttribute('vectorChild', Attribute::string(key: 'title', required: true));
+        $database->createRelationship(Relationship::manyToOne(
+            collection: 'vectorChild',
+            relatedCollection: 'vectorParent',
+            twoWay: true,
+            key: 'parent',
+            twoWayKey: 'children',
+        ));
 
         // Create parent documents with vectors
         $parent1 = $database->createDocument('vectorParent', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Parent 1',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $parent2 = $database->createDocument('vectorParent', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Parent 2',
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         // Create child documents
         $child1 = $database->createDocument('vectorChild', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'title' => 'Child 1',
-            'parent' => $parent1->getId()
+            'parent' => $parent1->getId(),
         ]));
 
         $child2 = $database->createDocument('vectorChild', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'title' => 'Child 2',
-            'parent' => $parent2->getId()
+            'parent' => $parent2->getId(),
         ]));
 
         // Query parents by vector similarity
         $results = $database->find('vectorParent', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -1462,13 +1006,16 @@ public function testVectorWithRelationships(): void
         // Verify relationships are intact
         $parent1Fetched = $database->getDocument('vectorParent', $parent1->getId());
         $children = $parent1Fetched->getAttribute('children');
+        $this->assertIsArray($children);
         $this->assertCount(1, $children);
-        $this->assertEquals('Child 1', $children[0]->getAttribute('title'));
+        $child = $children[0] ?? null;
+        $this->assertInstanceOf(Document::class, $child);
+        $this->assertEquals('Child 1', $child->getAttribute('title'));
 
         // Query with vector and relationship filter combined
         $results = $database->find('vectorParent', [
             Query::vectorCosine('embedding', [0.5, 0.5, 0.0]),
-            Query::equal('name', ['Parent 1'])
+            Query::equal('name', ['Parent 1']),
         ]);
 
         $this->assertCount(1, $results);
@@ -1483,52 +1030,59 @@ public function testVectorWithTwoWayRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create two collections with two-way relationship and vectors
-        $database->createCollection('vectorAuthors');
-        $database->createAttribute('vectorAuthors', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorAuthors', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        $database->createCollection('vectorBooks');
-        $database->createAttribute('vectorBooks', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorBooks', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createRelationship('vectorBooks', 'vectorAuthors', Database::RELATION_MANY_TO_ONE, true, 'author', 'books');
+        $database->createCollection(new Collection(id: 'vectorAuthors'));
+        $database->createAttribute('vectorAuthors', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorAuthors', Attribute::vector(key: 'embedding', size: 3, required: true));
+
+        $database->createCollection(new Collection(id: 'vectorBooks'));
+        $database->createAttribute('vectorBooks', Attribute::string(key: 'title', required: true));
+        $database->createAttribute('vectorBooks', Attribute::vector(key: 'embedding', size: 3, required: true));
+        $database->createRelationship(Relationship::manyToOne(
+            collection: 'vectorBooks',
+            relatedCollection: 'vectorAuthors',
+            twoWay: true,
+            key: 'author',
+            twoWayKey: 'books',
+        ));
 
         // Create documents
         $author = $database->createDocument('vectorAuthors', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Author 1',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $book1 = $database->createDocument('vectorBooks', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'title' => 'Book 1',
             'embedding' => [0.9, 0.1, 0.0],
-            'author' => $author->getId()
+            'author' => $author->getId(),
         ]));
 
         $book2 = $database->createDocument('vectorBooks', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'title' => 'Book 2',
             'embedding' => [0.8, 0.2, 0.0],
-            'author' => $author->getId()
+            'author' => $author->getId(),
         ]));
 
         // Query books by vector similarity
         $results = $database->find('vectorBooks', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertCount(1, $results);
@@ -1536,8 +1090,7 @@ public function testVectorWithTwoWayRelationships(): void
 
         // Query authors and verify relationship
         $authorFetched = $database->getDocument('vectorAuthors', $author->getId());
-        $books = $authorFetched->getAttribute('books');
-        $this->assertCount(2, $books);
+        $this->assertCount(2, $authorFetched->getDocuments('books'));
 
         // Cleanup
         $database->deleteCollection('vectorBooks');
@@ -1549,20 +1102,21 @@ public function testVectorAllZeros(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorZeros');
-        $database->createAttribute('vectorZeros', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorZeros'));
+        $database->createAttribute('vectorZeros', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create document with all-zeros vector
         $doc = $database->createDocument('vectorZeros', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [0.0, 0.0, 0.0]
+            'embedding' => [0.0, 0.0, 0.0],
         ]));
 
         $this->assertEquals([0.0, 0.0, 0.0], $doc->getAttribute('embedding'));
@@ -1570,14 +1124,14 @@ public function testVectorAllZeros(): void
         // Create another document with non-zero vector
         $doc2 = $database->createDocument('vectorZeros', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         // Query with zero vector - cosine similarity should handle gracefully
         $results = $database->find('vectorZeros', [
-            Query::vectorCosine('embedding', [0.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [0.0, 0.0, 0.0]),
         ]);
 
         // Should return documents, though similarity may be undefined
@@ -1585,7 +1139,7 @@ public function testVectorAllZeros(): void
 
         // Query with non-zero vector against zero vectors
         $results = $database->find('vectorZeros', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -1594,67 +1148,28 @@ public function testVectorAllZeros(): void
         $database->deleteCollection('vectorZeros');
     }
 
-    public function testVectorCosineSimilarityDivisionByZero(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorCosineZero');
-        $database->createAttribute('vectorCosineZero', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Create multiple documents with zero vectors
-        $database->createDocument('vectorCosineZero', new Document([
-            '$permissions' => [
-                Permission::read(Role::any())
-            ],
-            'embedding' => [0.0, 0.0, 0.0]
-        ]));
-
-        $database->createDocument('vectorCosineZero', new Document([
-            '$permissions' => [
-                Permission::read(Role::any())
-            ],
-            'embedding' => [0.0, 0.0, 0.0]
-        ]));
-
-        // Query with zero vector - should not cause division by zero error
-        $results = $database->find('vectorCosineZero', [
-            Query::vectorCosine('embedding', [0.0, 0.0, 0.0])
-        ]);
-
-        // Should handle gracefully and return results
-        $this->assertCount(2, $results);
-
-        // Cleanup
-        $database->deleteCollection('vectorCosineZero');
-    }
-
     public function testDeleteVectorAttribute(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorDeleteAttr');
-        $database->createAttribute('vectorDeleteAttr', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorDeleteAttr', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorDeleteAttr'));
+        $database->createAttribute('vectorDeleteAttr', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorDeleteAttr', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create document with vector
         $doc = $database->createDocument('vectorDeleteAttr', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Test',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $this->assertNotNull($doc->getAttribute('embedding'));
@@ -1665,9 +1180,9 @@ public function testDeleteVectorAttribute(): void
 
         // Verify attribute is gone
         $collection = $database->getCollection('vectorDeleteAttr');
-        $attributes = $collection->getAttribute('attributes');
+        $attributes = $collection->attributes;
         foreach ($attributes as $attr) {
-            $this->assertNotEquals('embedding', $attr['key']);
+            $this->assertNotEquals('embedding', $attr->getAttribute('key'));
         }
 
         // Fetch document - should not have embedding anymore
@@ -1683,24 +1198,25 @@ public function testDeleteAttributeWithVectorIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorDeleteIndexedAttr');
-        $database->createAttribute('vectorDeleteIndexedAttr', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorDeleteIndexedAttr'));
+        $database->createAttribute('vectorDeleteIndexedAttr', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create multiple indexes on the vector attribute
-        $database->createIndex('vectorDeleteIndexedAttr', 'idx1', Database::INDEX_HNSW_COSINE, ['embedding']);
-        $database->createIndex('vectorDeleteIndexedAttr', 'idx2', Database::INDEX_HNSW_EUCLIDEAN, ['embedding']);
+        $database->createIndex('vectorDeleteIndexedAttr', Index::hnswCosine(key: 'idx1', attributes: ['embedding']));
+        $database->createIndex('vectorDeleteIndexedAttr', Index::hnswEuclidean(key: 'idx2', attributes: ['embedding']));
 
         // Create document
         $database->createDocument('vectorDeleteIndexedAttr', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         // Delete the attribute - should also delete indexes
@@ -1709,163 +1225,43 @@ public function testDeleteAttributeWithVectorIndexes(): void
 
         // Verify indexes are gone
         $collection = $database->getCollection('vectorDeleteIndexedAttr');
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(0, $indexes);
 
         // Cleanup
         $database->deleteCollection('vectorDeleteIndexedAttr');
     }
 
-    public function testVectorSearchWithRestrictedPermissions(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        // Create documents with different permissions inside Authorization::skip
-        $database->getAuthorization()->skip(function () use ($database) {
-            $database->createCollection('vectorPermissions', [], [], [], true);
-            $database->createAttribute('vectorPermissions', 'name', Database::VAR_STRING, 255, true);
-            $database->createAttribute('vectorPermissions', 'embedding', Database::VAR_VECTOR, 3, true);
-
-            $database->createDocument('vectorPermissions', new Document([
-                '$permissions' => [
-                    Permission::read(Role::user('user1'))
-                ],
-                'name' => 'Doc 1',
-                'embedding' => [1.0, 0.0, 0.0]
-            ]));
-
-            $database->createDocument('vectorPermissions', new Document([
-                '$permissions' => [
-                    Permission::read(Role::user('user2'))
-                ],
-                'name' => 'Doc 2',
-                'embedding' => [0.9, 0.1, 0.0]
-            ]));
-
-            $database->createDocument('vectorPermissions', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'name' => 'Doc 3',
-                'embedding' => [0.8, 0.2, 0.0]
-            ]));
-        });
-
-        // Query as user1 - should only see doc1 and doc3
-        $database->getAuthorization()->addRole(Role::user('user1')->toString());
-        $database->getAuthorization()->addRole(Role::any()->toString());
-        $results = $database->find('vectorPermissions', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
-        ]);
-
-        $this->assertCount(2, $results);
-        $names = array_map(fn ($d) => $d->getAttribute('name'), $results);
-        $this->assertContains('Doc 1', $names);
-        $this->assertContains('Doc 3', $names);
-        $this->assertNotContains('Doc 2', $names);
-
-        // Query as user2 - should only see doc2 and doc3
-        $database->getAuthorization()->cleanRoles();
-        $database->getAuthorization()->addRole(Role::user('user2')->toString());
-        $database->getAuthorization()->addRole(Role::any()->toString());
-        $results = $database->find('vectorPermissions', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
-        ]);
-
-        $this->assertCount(2, $results);
-        $names = array_map(fn ($d) => $d->getAttribute('name'), $results);
-        $this->assertContains('Doc 2', $names);
-        $this->assertContains('Doc 3', $names);
-        $this->assertNotContains('Doc 1', $names);
-
-        $database->getAuthorization()->cleanRoles();
-        $database->getAuthorization()->addRole(Role::any()->toString());
-
-        // Cleanup
-        $database->deleteCollection('vectorPermissions');
-    }
-
-    public function testVectorPermissionFilteringAfterScoring(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorPermScoring');
-        $database->createAttribute('vectorPermScoring', 'score', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('vectorPermScoring', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Create 5 documents, top 3 by similarity have restricted access
-        for ($i = 0; $i < 5; $i++) {
-            $perms = $i < 3
-                ? [Permission::read(Role::user('restricted'))]
-                : [Permission::read(Role::any())];
-
-            $database->createDocument('vectorPermScoring', new Document([
-                '$permissions' => $perms,
-                'score' => $i,
-                'embedding' => [1.0 - ($i * 0.1), $i * 0.1, 0.0]
-            ]));
-        }
-
-        // Query with limit 3 as any user - should skip restricted docs and return accessible ones
-        $database->getAuthorization()->addRole(Role::any()->toString());
-        $results = $database->find('vectorPermScoring', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(3)
-        ]);
-
-        // Should only get the 2 accessible documents
-        $this->assertCount(2, $results);
-        foreach ($results as $doc) {
-            $this->assertGreaterThanOrEqual(3, $doc->getAttribute('score'));
-        }
-
-        $database->getAuthorization()->cleanRoles();
-
-        // Cleanup
-        $database->deleteCollection('vectorPermScoring');
-    }
-
     public function testVectorCursorBeforePagination(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorCursorBefore');
-        $database->createAttribute('vectorCursorBefore', 'index', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('vectorCursorBefore', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorCursorBefore'));
+        $database->createAttribute('vectorCursorBefore', Attribute::integer(key: 'index', required: true));
+        $database->createAttribute('vectorCursorBefore', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create 10 documents
         for ($i = 0; $i < 10; $i++) {
             $database->createDocument('vectorCursorBefore', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'index' => $i,
-                'embedding' => [1.0 - ($i * 0.05), $i * 0.05, 0.0]
+                'embedding' => [1.0 - ($i * 0.05), $i * 0.05, 0.0],
             ]));
         }
 
         // Get first 5 results
         $firstBatch = $database->find('vectorCursorBefore', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(5, $firstBatch);
@@ -1875,7 +1271,7 @@ public function testVectorCursorBeforePagination(): void
         $beforeBatch = $database->find('vectorCursorBefore', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::cursorBefore($fourthDoc),
-            Query::limit(3)
+            Query::limit(3),
         ]);
 
         // Should get the 3 documents before the 4th one
@@ -1892,30 +1288,31 @@ public function testVectorBackwardPagination(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorBackward');
-        $database->createAttribute('vectorBackward', 'value', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('vectorBackward', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorBackward'));
+        $database->createAttribute('vectorBackward', Attribute::integer(key: 'value', required: true));
+        $database->createAttribute('vectorBackward', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents
         for ($i = 0; $i < 20; $i++) {
             $database->createDocument('vectorBackward', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'value' => $i,
-                'embedding' => [cos($i * 0.1), sin($i * 0.1), 0.0]
+                'embedding' => [cos($i * 0.1), sin($i * 0.1), 0.0],
             ]));
         }
 
         // Get last batch
         $allResults = $database->find('vectorBackward', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(20)
+            Query::limit(20),
         ]);
 
         // Navigate backwards from the end
@@ -1923,7 +1320,7 @@ public function testVectorBackwardPagination(): void
         $backwardBatch = $database->find('vectorBackward', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::cursorBefore($lastDoc),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(5, $backwardBatch);
@@ -1933,7 +1330,7 @@ public function testVectorBackwardPagination(): void
         $moreBackward = $database->find('vectorBackward', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::cursorBefore($firstOfBackward),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         // Should get at least some results (may be less than 5 due to cursor position)
@@ -1949,112 +1346,71 @@ public function testVectorDimensionUpdate(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorDimUpdate');
-        $database->createAttribute('vectorDimUpdate', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorDimUpdate'));
+        $database->createAttribute('vectorDimUpdate', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create document
         $doc = $database->createDocument('vectorDimUpdate', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
-        $this->assertCount(3, $doc->getAttribute('embedding'));
+        $this->assertCount(3, $doc->getArray('embedding'));
 
         // Try to update attribute dimensions - should fail (immutable)
         try {
-            $database->updateAttribute('vectorDimUpdate', 'embedding', Database::VAR_VECTOR, 5, true);
+            $database->updateAttribute('vectorDimUpdate', 'embedding', ColumnType::Vector->value, 5, true);
             $this->fail('Should not allow changing vector dimensions');
         } catch (\Throwable $e) {
-            // Expected - dimension changes not allowed (either validation or database error)
-            $this->assertTrue(true);
+            $this->assertNotSame('', $e->getMessage());
         }
 
         // Cleanup
         $database->deleteCollection('vectorDimUpdate');
     }
 
-    public function testVectorRequiredWithNullValue(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorRequiredNull');
-        $database->createAttribute('vectorRequiredNull', 'embedding', Database::VAR_VECTOR, 3, true); // Required
-
-        // Try to create document with null required vector - should fail
-        try {
-            $database->createDocument('vectorRequiredNull', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => null
-            ]));
-            $this->fail('Should have thrown exception for null required vector');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('required', strtolower($e->getMessage()));
-        }
-
-        // Try to create document without vector attribute - should fail
-        try {
-            $database->createDocument('vectorRequiredNull', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ]
-            ]));
-            $this->fail('Should have thrown exception for missing required vector');
-        } catch (DatabaseException $e) {
-            $this->assertTrue(true);
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorRequiredNull');
-    }
-
     public function testVectorConcurrentUpdates(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorConcurrent');
-        $database->createAttribute('vectorConcurrent', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorConcurrent', 'version', Database::VAR_INTEGER, 0, true);
+        $database->createCollection(new Collection(id: 'vectorConcurrent'));
+        $database->createAttribute('vectorConcurrent', Attribute::vector(key: 'embedding', size: 3, required: true));
+        $database->createAttribute('vectorConcurrent', Attribute::integer(key: 'version', required: true));
 
         // Create initial document
         $doc = $database->createDocument('vectorConcurrent', new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
+                Permission::update(Role::any()),
             ],
             'embedding' => [1.0, 0.0, 0.0],
-            'version' => 1
+            'version' => 1,
         ]));
 
         // Simulate concurrent updates
         $update1 = $database->updateDocument('vectorConcurrent', $doc->getId(), new Document([
             'embedding' => [0.0, 1.0, 0.0],
-            'version' => 2
+            'version' => 2,
         ]));
 
         $update2 = $database->updateDocument('vectorConcurrent', $doc->getId(), new Document([
             'embedding' => [0.0, 0.0, 1.0],
-            'version' => 3
+            'version' => 3,
         ]));
 
         // Last update should win
@@ -2071,28 +1427,29 @@ public function testDeleteVectorIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorDeleteIdx');
-        $database->createAttribute('vectorDeleteIdx', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorDeleteIdx'));
+        $database->createAttribute('vectorDeleteIdx', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create index
-        $database->createIndex('vectorDeleteIdx', 'idx_cosine', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorDeleteIdx', Index::hnswCosine(key: 'idx_cosine', attributes: ['embedding']));
 
         // Verify index exists
         $collection = $database->getCollection('vectorDeleteIdx');
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(1, $indexes);
 
         // Create documents
         $database->createDocument('vectorDeleteIdx', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         // Delete index
@@ -2101,12 +1458,12 @@ public function testDeleteVectorIndexes(): void
 
         // Verify index is gone
         $collection = $database->getCollection('vectorDeleteIdx');
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(0, $indexes);
 
         // Queries should still work (without index optimization)
         $results = $database->find('vectorDeleteIdx', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(1, $results);
@@ -2120,42 +1477,43 @@ public function testMultipleVectorIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorMultiIdx');
-        $database->createAttribute('vectorMultiIdx', 'embedding1', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorMultiIdx', 'embedding2', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorMultiIdx'));
+        $database->createAttribute('vectorMultiIdx', Attribute::vector(key: 'embedding1', size: 3, required: true));
+        $database->createAttribute('vectorMultiIdx', Attribute::vector(key: 'embedding2', size: 3, required: true));
 
         // Create multiple indexes on different vector attributes
-        $database->createIndex('vectorMultiIdx', 'idx1_cosine', Database::INDEX_HNSW_COSINE, ['embedding1']);
-        $database->createIndex('vectorMultiIdx', 'idx2_euclidean', Database::INDEX_HNSW_EUCLIDEAN, ['embedding2']);
+        $database->createIndex('vectorMultiIdx', Index::hnswCosine(key: 'idx1_cosine', attributes: ['embedding1']));
+        $database->createIndex('vectorMultiIdx', Index::hnswEuclidean(key: 'idx2_euclidean', attributes: ['embedding2']));
 
         // Verify both indexes exist
         $collection = $database->getCollection('vectorMultiIdx');
-        $indexes = $collection->getAttribute('indexes');
+        $indexes = $collection->indexes;
         $this->assertCount(2, $indexes);
 
         // Create document
         $database->createDocument('vectorMultiIdx', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'embedding1' => [1.0, 0.0, 0.0],
-            'embedding2' => [0.0, 1.0, 0.0]
+            'embedding2' => [0.0, 1.0, 0.0],
         ]));
 
         // Query using first index
         $results = $database->find('vectorMultiIdx', [
-            Query::vectorCosine('embedding1', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding1', [1.0, 0.0, 0.0]),
         ]);
         $this->assertCount(1, $results);
 
         // Query using second index
         $results = $database->find('vectorMultiIdx', [
-            Query::vectorEuclidean('embedding2', [0.0, 1.0, 0.0])
+            Query::vectorEuclidean('embedding2', [0.0, 1.0, 0.0]),
         ]);
         $this->assertCount(1, $results);
 
@@ -2163,72 +1521,38 @@ public function testMultipleVectorIndexes(): void
         $database->deleteCollection('vectorMultiIdx');
     }
 
-    public function testVectorIndexCreationFailure(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorIdxFail');
-        $database->createAttribute('vectorIdxFail', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorIdxFail', 'text', Database::VAR_STRING, 255, true);
-
-        // Try to create vector index on non-vector attribute - should fail
-        try {
-            $database->createIndex('vectorIdxFail', 'bad_idx', Database::INDEX_HNSW_COSINE, ['text']);
-            $this->fail('Should not allow vector index on non-vector attribute');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('vector', strtolower($e->getMessage()));
-        }
-
-        // Try to create duplicate index
-        $database->createIndex('vectorIdxFail', 'idx1', Database::INDEX_HNSW_COSINE, ['embedding']);
-        try {
-            $database->createIndex('vectorIdxFail', 'idx1', Database::INDEX_HNSW_COSINE, ['embedding']);
-            $this->fail('Should not allow duplicate index');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('index', strtolower($e->getMessage()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorIdxFail');
-    }
-
     public function testVectorQueryWithoutIndex(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorNoIndex');
-        $database->createAttribute('vectorNoIndex', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorNoIndex'));
+        $database->createAttribute('vectorNoIndex', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents without any index
         $database->createDocument('vectorNoIndex', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $database->createDocument('vectorNoIndex', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [0.0, 1.0, 0.0]
+            'embedding' => [0.0, 1.0, 0.0],
         ]));
 
         // Queries should still work (sequential scan)
         $results = $database->find('vectorNoIndex', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -2242,17 +1566,18 @@ public function testVectorQueryEmpty(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorEmptyQuery');
-        $database->createAttribute('vectorEmptyQuery', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorEmptyQuery'));
+        $database->createAttribute('vectorEmptyQuery', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // No documents in collection
         $results = $database->find('vectorEmptyQuery', [
-            Query::vectorCosine('embedding', [1.0, 0.0, 0.0])
+            Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
         ]);
 
         $this->assertCount(0, $results);
@@ -2266,27 +1591,28 @@ public function testSingleDimensionVector(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorSingleDim');
-        $database->createAttribute('vectorSingleDim', 'embedding', Database::VAR_VECTOR, 1, true);
+        $database->createCollection(new Collection(id: 'vectorSingleDim'));
+        $database->createAttribute('vectorSingleDim', Attribute::vector(key: 'embedding', size: 1, required: true));
 
         // Create documents with single-dimension vectors
         $doc1 = $database->createDocument('vectorSingleDim', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1.0]
+            'embedding' => [1.0],
         ]));
 
         $doc2 = $database->createDocument('vectorSingleDim', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [0.5]
+            'embedding' => [0.5],
         ]));
 
         $this->assertEquals([1.0], $doc1->getAttribute('embedding'));
@@ -2294,7 +1620,7 @@ public function testSingleDimensionVector(): void
 
         // Query with single dimension
         $results = $database->find('vectorSingleDim', [
-            Query::vectorCosine('embedding', [1.0])
+            Query::vectorCosine('embedding', [1.0]),
         ]);
 
         $this->assertCount(2, $results);
@@ -2308,32 +1634,33 @@ public function testVectorLongResultSet(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorLongResults');
-        $database->createAttribute('vectorLongResults', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorLongResults'));
+        $database->createAttribute('vectorLongResults', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create 100 documents
         for ($i = 0; $i < 100; $i++) {
             $database->createDocument('vectorLongResults', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'embedding' => [
                     sin($i * 0.1),
                     cos($i * 0.1),
-                    sin($i * 0.05)
-                ]
+                    sin($i * 0.05),
+                ],
             ]));
         }
 
         // Query all results
         $results = $database->find('vectorLongResults', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(100)
+            Query::limit(100),
         ]);
 
         $this->assertCount(100, $results);
@@ -2347,42 +1674,43 @@ public function testMultipleVectorQueriesOnSameCollection(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorMultiQuery');
-        $database->createAttribute('vectorMultiQuery', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorMultiQuery'));
+        $database->createAttribute('vectorMultiQuery', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents
         for ($i = 0; $i < 10; $i++) {
             $database->createDocument('vectorMultiQuery', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'embedding' => [
                     cos($i * M_PI / 10),
                     sin($i * M_PI / 10),
-                    0.0
-                ]
+                    0.0,
+                ],
             ]));
         }
 
         // Execute multiple different vector queries
         $results1 = $database->find('vectorMultiQuery', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $results2 = $database->find('vectorMultiQuery', [
             Query::vectorEuclidean('embedding', [0.0, 1.0, 0.0]),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $results3 = $database->find('vectorMultiQuery', [
             Query::vectorDot('embedding', [0.5, 0.5, 0.0]),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         // All should return results
@@ -2400,75 +1728,33 @@ public function testMultipleVectorQueriesOnSameCollection(): void
         $database->deleteCollection('vectorMultiQuery');
     }
 
-    public function testVectorNonNumericValidationE2E(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('vectorNonNumeric');
-        $database->createAttribute('vectorNonNumeric', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test null value in array
-        try {
-            $database->createDocument('vectorNonNumeric', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [1.0, null, 0.0]
-            ]));
-            $this->fail('Should reject null in vector array');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
-
-        // Test object in array
-        try {
-            $database->createDocument('vectorNonNumeric', new Document([
-                '$permissions' => [
-                    Permission::read(Role::any())
-                ],
-                'embedding' => [1.0, (object)['x' => 1], 0.0]
-            ]));
-            $this->fail('Should reject object in vector array');
-        } catch (\Throwable $e) {
-            $this->assertTrue(true);
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorNonNumeric');
-    }
-
     public function testVectorLargeValues(): void
     {
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorLargeVals');
-        $database->createAttribute('vectorLargeVals', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorLargeVals'));
+        $database->createAttribute('vectorLargeVals', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Test with very large float values (but not INF)
         $doc = $database->createDocument('vectorLargeVals', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => [1e38, -1e38, 1e37]
+            'embedding' => [1e38, -1e38, 1e37],
         ]));
 
-        $this->assertNotNull($doc->getId());
+        $this->assertNotSame('', $doc->getId());
 
         // Query should work
         $results = $database->find('vectorLargeVals', [
-            Query::vectorCosine('embedding', [1e38, -1e38, 1e37])
+            Query::vectorCosine('embedding', [1e38, -1e38, 1e37]),
         ]);
 
         $this->assertCount(1, $results);
@@ -2482,25 +1768,26 @@ public function testVectorPrecisionLoss(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorPrecision');
-        $database->createAttribute('vectorPrecision', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorPrecision'));
+        $database->createAttribute('vectorPrecision', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create vector with high precision values
         $highPrecision = [0.123456789012345, 0.987654321098765, 0.555555555555555];
         $doc = $database->createDocument('vectorPrecision', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => $highPrecision
+            'embedding' => $highPrecision,
         ]));
 
         // Retrieve and check precision (may have some loss)
-        $retrieved = $doc->getAttribute('embedding');
+        $retrieved = $doc->getArray('embedding');
         $this->assertCount(3, $retrieved);
 
         // Values should be close to original (allowing for float precision)
@@ -2517,14 +1804,15 @@ public function testVector16000DimensionsBoundary(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Test exactly 16000 dimensions (pgvector limit)
-        $database->createCollection('vector16000');
-        $database->createAttribute('vector16000', 'embedding', Database::VAR_VECTOR, 16000, true);
+        $database->createCollection(new Collection(id: 'vector16000'));
+        $database->createAttribute('vector16000', Attribute::vector(key: 'embedding', size: 16000, required: true));
 
         // Create a vector with exactly 16000 dimensions
         $largeVector = array_fill(0, 16000, 0.1);
@@ -2532,12 +1820,14 @@ public function testVector16000DimensionsBoundary(): void
 
         $doc = $database->createDocument('vector16000', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
-            'embedding' => $largeVector
+            'embedding' => $largeVector,
         ]));
 
-        $this->assertCount(16000, $doc->getAttribute('embedding'));
+        $embedding = $doc->getAttribute('embedding');
+        $this->assertIsArray($embedding);
+        $this->assertCount(16000, $embedding);
 
         // Query should work
         $searchVector = array_fill(0, 16000, 0.0);
@@ -2545,7 +1835,7 @@ public function testVector16000DimensionsBoundary(): void
 
         $results = $database->find('vector16000', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertCount(1, $results);
@@ -2559,13 +1849,14 @@ public function testVectorLargeDatasetIndexBuild(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorLargeDataset');
-        $database->createAttribute('vectorLargeDataset', 'embedding', Database::VAR_VECTOR, 128, true);
+        $database->createCollection(new Collection(id: 'vectorLargeDataset'));
+        $database->createAttribute('vectorLargeDataset', Attribute::vector(key: 'embedding', size: 128, required: true));
 
         // Create 200 documents
         for ($i = 0; $i < 200; $i++) {
@@ -2576,20 +1867,20 @@ public function testVectorLargeDatasetIndexBuild(): void
 
             $database->createDocument('vectorLargeDataset', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => $vector
+                'embedding' => $vector,
             ]));
         }
 
         // Create index on large dataset
-        $database->createIndex('vectorLargeDataset', 'idx_hnsw', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorLargeDataset', Index::hnswCosine(key: 'idx_hnsw', attributes: ['embedding']));
 
         // Verify queries work
         $searchVector = array_fill(0, 128, 0.5);
         $results = $database->find('vectorLargeDataset', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(10)
+            Query::limit(10),
         ]);
 
         $this->assertCount(10, $results);
@@ -2603,44 +1894,45 @@ public function testVectorFilterDisabled(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorFilterDisabled');
-        $database->createAttribute('vectorFilterDisabled', 'status', Database::VAR_STRING, 50, true);
-        $database->createAttribute('vectorFilterDisabled', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorFilterDisabled'));
+        $database->createAttribute('vectorFilterDisabled', Attribute::string(key: 'status', size: 50, required: true));
+        $database->createAttribute('vectorFilterDisabled', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents
         $database->createDocument('vectorFilterDisabled', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'status' => 'active',
-            'embedding' => [1.0, 0.0, 0.0]
+            'embedding' => [1.0, 0.0, 0.0],
         ]));
 
         $database->createDocument('vectorFilterDisabled', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'status' => 'disabled',
-            'embedding' => [0.9, 0.1, 0.0]
+            'embedding' => [0.9, 0.1, 0.0],
         ]));
 
         $database->createDocument('vectorFilterDisabled', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'status' => 'active',
-            'embedding' => [0.8, 0.2, 0.0]
+            'embedding' => [0.8, 0.2, 0.0],
         ]));
 
         // Query with filter excluding disabled
         $results = $database->find('vectorFilterDisabled', [
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
-            Query::notEqual('status', ['disabled'])
+            Query::notEqual('status', ['disabled']),
         ]);
 
         $this->assertCount(2, $results);
@@ -2657,25 +1949,26 @@ public function testVectorFilterOverride(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorFilterOverride');
-        $database->createAttribute('vectorFilterOverride', 'category', Database::VAR_STRING, 50, true);
-        $database->createAttribute('vectorFilterOverride', 'priority', Database::VAR_INTEGER, 0, true);
-        $database->createAttribute('vectorFilterOverride', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorFilterOverride'));
+        $database->createAttribute('vectorFilterOverride', Attribute::string(key: 'category', size: 50, required: true));
+        $database->createAttribute('vectorFilterOverride', Attribute::integer(key: 'priority', required: true));
+        $database->createAttribute('vectorFilterOverride', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         // Create documents
         for ($i = 0; $i < 5; $i++) {
             $database->createDocument('vectorFilterOverride', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'category' => $i < 3 ? 'A' : 'B',
                 'priority' => $i,
-                'embedding' => [1.0 - ($i * 0.1), $i * 0.1, 0.0]
+                'embedding' => [1.0 - ($i * 0.1), $i * 0.1, 0.0],
             ]));
         }
 
@@ -2684,7 +1977,7 @@ public function testVectorFilterOverride(): void
             Query::vectorCosine('embedding', [1.0, 0.0, 0.0]),
             Query::equal('category', ['A']),
             Query::greaterThan('priority', 0),
-            Query::limit(2)
+            Query::limit(2),
         ]);
 
         // Should get category A documents with priority > 0
@@ -2703,31 +1996,32 @@ public function testMultipleFiltersOnVectorAttribute(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorMultiFilters');
-        $database->createAttribute('vectorMultiFilters', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorMultiFilters', 'embedding1', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorMultiFilters', 'embedding2', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorMultiFilters'));
+        $database->createAttribute('vectorMultiFilters', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorMultiFilters', Attribute::vector(key: 'embedding1', size: 3, required: true));
+        $database->createAttribute('vectorMultiFilters', Attribute::vector(key: 'embedding2', size: 3, required: true));
 
         // Create documents
         $database->createDocument('vectorMultiFilters', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Doc 1',
             'embedding1' => [1.0, 0.0, 0.0],
-            'embedding2' => [0.0, 1.0, 0.0]
+            'embedding2' => [0.0, 1.0, 0.0],
         ]));
 
         // Try to use multiple vector queries - should reject
         try {
             $database->find('vectorMultiFilters', [
                 Query::vectorCosine('embedding1', [1.0, 0.0, 0.0]),
-                Query::vectorCosine('embedding2', [0.0, 1.0, 0.0])
+                Query::vectorCosine('embedding2', [0.0, 1.0, 0.0]),
             ]);
             $this->fail('Should not allow multiple vector queries');
         } catch (DatabaseException $e) {
@@ -2743,24 +2037,25 @@ public function testVectorQueryInNestedQuery(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorNested');
-        $database->createAttribute('vectorNested', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('vectorNested', 'embedding1', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorNested', 'embedding2', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorNested'));
+        $database->createAttribute('vectorNested', Attribute::string(key: 'name', required: true));
+        $database->createAttribute('vectorNested', Attribute::vector(key: 'embedding1', size: 3, required: true));
+        $database->createAttribute('vectorNested', Attribute::vector(key: 'embedding2', size: 3, required: true));
 
         // Create document
         $database->createDocument('vectorNested', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'name' => 'Doc 1',
             'embedding1' => [1.0, 0.0, 0.0],
-            'embedding2' => [0.0, 1.0, 0.0]
+            'embedding2' => [0.0, 1.0, 0.0],
         ]));
 
         // Try to use vector query in nested OR clause with another vector query - should reject
@@ -2769,8 +2064,8 @@ public function testVectorQueryInNestedQuery(): void
                 Query::vectorCosine('embedding1', [1.0, 0.0, 0.0]),
                 Query::or([
                     Query::vectorCosine('embedding2', [0.0, 1.0, 0.0]),
-                    Query::equal('name', ['Doc 1'])
-                ])
+                    Query::equal('name', ['Doc 1']),
+                ]),
             ]);
             $this->fail('Should not allow multiple vector queries across nested queries');
         } catch (DatabaseException $e) {
@@ -2786,17 +2081,18 @@ public function testVectorQueryCount(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorCount');
-        $database->createAttribute('vectorCount', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorCount'));
+        $database->createAttribute('vectorCount', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         $database->createDocument('vectorCount', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'embedding' => [1.0, 0.0, 0.0],
         ]));
@@ -2815,38 +2111,39 @@ public function testVectorQuerySum(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorSum');
-        $database->createAttribute('vectorSum', 'embedding', Database::VAR_VECTOR, 3, true);
-        $database->createAttribute('vectorSum', 'value', Database::VAR_INTEGER, 0, true);
+        $database->createCollection(new Collection(id: 'vectorSum'));
+        $database->createAttribute('vectorSum', Attribute::vector(key: 'embedding', size: 3, required: true));
+        $database->createAttribute('vectorSum', Attribute::integer(key: 'value', required: true));
 
         // Create documents with different values
         $database->createDocument('vectorSum', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'embedding' => [1.0, 0.0, 0.0],
-            'value' => 10
+            'value' => 10,
         ]));
 
         $database->createDocument('vectorSum', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'embedding' => [0.0, 1.0, 0.0],
-            'value' => 20
+            'value' => 20,
         ]));
 
         $database->createDocument('vectorSum', new Document([
             '$permissions' => [
-                Permission::read(Role::any())
+                Permission::read(Role::any()),
             ],
             'embedding' => [0.5, 0.5, 0.0],
-            'value' => 30
+            'value' => 30,
         ]));
 
         // Test sum with vector query - should sum all matching documents
@@ -2872,19 +2169,20 @@ public function testVectorUpsert(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('vectorUpsert');
-        $database->createAttribute('vectorUpsert', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createCollection(new Collection(id: 'vectorUpsert'));
+        $database->createAttribute('vectorUpsert', Attribute::vector(key: 'embedding', size: 3, required: true));
 
         $insertedDoc = $database->upsertDocument('vectorUpsert', new Document([
             '$id' => 'vectorUpsert',
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
+                Permission::update(Role::any()),
             ],
             'embedding' => [1.0, 0.0, 0.0],
         ]));
@@ -2898,7 +2196,7 @@ public function testVectorUpsert(): void
             '$id' => 'vectorUpsert',
             '$permissions' => [
                 Permission::read(Role::any()),
-                Permission::update(Role::any())
+                Permission::update(Role::any()),
             ],
             'embedding' => [2.0, 0.0, 0.0],
         ]));
diff --git a/tests/e2e/Adapter/SharedTables/MariaDBTest.php b/tests/e2e/Adapter/SharedTables/MariaDBTest.php
index f6574ab0de..6a0467fef3 100644
--- a/tests/e2e/Adapter/SharedTables/MariaDBTest.php
+++ b/tests/e2e/Adapter/SharedTables/MariaDBTest.php
@@ -13,26 +13,23 @@
 class MariaDBTest extends Base
 {
     protected static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     // Remove once all methods are implemented
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "mariadb";
+        return 'mariadb';
     }
 
-    /**
-     * @return Database
-     */
     public function getDatabase(bool $fresh = false): Database
     {
-        if (!is_null(self::$database) && !$fresh) {
+        if (! is_null(self::$database) && ! $fresh) {
             return self::$database;
         }
 
@@ -44,18 +41,18 @@ public function getDatabase(bool $fresh = false): Database
         $pdo = new PDO("mysql:host={$dbHost};port={$dbPort};charset=utf8mb4", $dbUser, $dbPass, MariaDB::getPDOAttributes());
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(7);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new MariaDB($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setSharedTables(true)
             ->setTenant(999)
-            ->setNamespace(static::$namespace = '')
-            ->enableLocks(true)
-        ;
+            ->setNamespace(static::$namespace = 'st_'.static::getTestToken())
+            ->enableLocks(true);
 
         if ($database->exists()) {
             $database->delete();
@@ -64,14 +61,16 @@ public function getDatabase(bool $fresh = false): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -79,9 +78,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/SharedTables/MongoDBTest.php b/tests/e2e/Adapter/SharedTables/MongoDBTest.php
index 61904861c1..5b95b1fcd4 100644
--- a/tests/e2e/Adapter/SharedTables/MongoDBTest.php
+++ b/tests/e2e/Adapter/SharedTables/MongoDBTest.php
@@ -14,34 +14,32 @@
 class MongoDBTest extends Base
 {
     public static ?Database $database = null;
+
     protected static string $namespace;
 
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "mongodb";
+        return 'mongodb';
     }
 
     /**
-     * @return Database
      * @throws Exception
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(11);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
-        $schema = 'utopiaTests'; // same as $this->testDatabase
+        $schema = $this->testDatabase;
         $client = new Client(
             $schema,
             'mongo',
@@ -52,12 +50,13 @@ public function getDatabase(): Database
         );
 
         $database = new Database(new Mongo($client), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
             ->setDatabase($schema)
             ->setSharedTables(true)
             ->setTenant(999)
-            ->setNamespace(static::$namespace = 'my_shared_tables');
+            ->setNamespace(static::$namespace = 'st_'.static::getTestToken());
 
         if ($database->exists()) {
             $database->delete();
@@ -71,33 +70,33 @@ public function getDatabase(): Database
     /**
      * @throws Exception
      */
-    public function testCreateExistsDelete(): void
+    public function test_create_exists_delete(): void
     {
         // Mongo creates databases on the fly, so exists would always pass. So we override this test to remove the exists check.
-        $this->assertNotNull($this->getDatabase()->create());
+        $this->assertSame(true, $this->getDatabase()->create());
         $this->assertEquals(true, $this->getDatabase()->delete($this->testDatabase));
         $this->assertEquals(true, $this->getDatabase()->create());
         $this->assertEquals($this->getDatabase(), $this->getDatabase()->setDatabase($this->testDatabase));
     }
 
-    public function testRenameAttribute(): void
+    public function test_rename_attribute(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testRenameAttributeExisting(): void
+    public function test_rename_attribute_existing(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testUpdateAttributeStructure(): void
+    public function test_update_attribute_structure(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
-    public function testKeywords(): void
+    public function test_keywords(): void
     {
-        $this->assertTrue(true);
+        $this->markTestSkipped('Not supported by MongoDB adapter');
     }
 
     protected function deleteColumn(string $collection, string $column): bool
diff --git a/tests/e2e/Adapter/SharedTables/MySQLTest.php b/tests/e2e/Adapter/SharedTables/MySQLTest.php
index 697c42c7ea..a90826cbbd 100644
--- a/tests/e2e/Adapter/SharedTables/MySQLTest.php
+++ b/tests/e2e/Adapter/SharedTables/MySQLTest.php
@@ -13,26 +13,23 @@
 class MySQLTest extends Base
 {
     public static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     // Remove once all methods are implemented
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "mysql";
+        return 'mysql';
     }
 
-    /**
-     * @return Database
-     */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
@@ -45,19 +42,19 @@ public function getDatabase(): Database
 
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
+        $redis->select(8);
 
-        $cache = new Cache(new RedisAdapter($redis));
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new MySQL($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setSharedTables(true)
             ->setTenant(999)
-            ->setNamespace(static::$namespace = '')
-            ->enableLocks(true)
-        ;
+            ->setNamespace(static::$namespace = 'st_'.static::getTestToken())
+            ->enableLocks(true);
 
         if ($database->exists()) {
             $database->delete();
@@ -66,14 +63,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -81,9 +80,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getDatabase() . "`.`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getDatabase().'`.`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "DROP INDEX `{$index}` ON {$sqlTable}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/SharedTables/PostgresTest.php b/tests/e2e/Adapter/SharedTables/PostgresTest.php
index cb9633c019..6536ecc022 100644
--- a/tests/e2e/Adapter/SharedTables/PostgresTest.php
+++ b/tests/e2e/Adapter/SharedTables/PostgresTest.php
@@ -13,17 +13,17 @@
 class PostgresTest extends Base
 {
     public static ?Database $database = null;
+
     public static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "postgres";
+        return 'postgres';
     }
 
     /**
@@ -31,7 +31,7 @@ public static function getAdapterName(): string
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
@@ -43,16 +43,17 @@ public function getDatabase(): Database
         $pdo = new PDO("pgsql:host={$dbHost};port={$dbPort};", $dbUser, $dbPass, Postgres::getPDOAttributes());
         $redis = new Redis();
         $redis->connect('redis', 6379);
-        $redis->flushAll();
-        $cache = new Cache(new RedisAdapter($redis));
+        $redis->select(9);
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $database = new Database(new Postgres($pdo), $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setSharedTables(true)
             ->setTenant(999)
-            ->setNamespace(static::$namespace = '');
+            ->setNamespace(static::$namespace = 'st_'.static::getTestToken());
 
         if ($database->exists()) {
             $database->delete();
@@ -61,14 +62,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = '"' . $this->getDatabase()->getDatabase() . '"."' . $this->getDatabase()->getNamespace() . '_' . $collection . '"';
+        $sqlTable = '"'.$this->getDatabase()->getDatabase().'"."'.$this->getDatabase()->getNamespace().'_'.$collection.'"';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN \"{$column}\"";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -76,10 +79,11 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $key = "\"".$this->getDatabase()->getNamespace()."_".$this->getDatabase()->getTenant()."_{$collection}_{$index}\"";
+        $key = '"'.$this->getDatabase()->getNamespace().'_'.$this->getDatabase()->getTenant()."_{$collection}_{$index}\"";
 
-        $sql = "DROP INDEX \"".$this->getDatabase()->getDatabase()."\".{$key}";
+        $sql = 'DROP INDEX "'.$this->getDatabase()->getDatabase()."\".{$key}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/SharedTables/SQLiteTest.php b/tests/e2e/Adapter/SharedTables/SQLiteTest.php
index 1701bc8dcc..3f67e48051 100644
--- a/tests/e2e/Adapter/SharedTables/SQLiteTest.php
+++ b/tests/e2e/Adapter/SharedTables/SQLiteTest.php
@@ -13,55 +13,53 @@
 class SQLiteTest extends Base
 {
     public static ?Database $database = null;
+
     public static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     // Remove once all methods are implemented
     /**
      * Return name of adapter
-     *
-     * @return string
      */
     public static function getAdapterName(): string
     {
-        return "sqlite";
+        return 'sqlite';
     }
 
-    /**
-     * @return Database
-     */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
-        $db = __DIR__."/database.sql";
+        $db = __DIR__.'/database_'.static::getTestToken().'.sql';
 
         if (file_exists($db)) {
             unlink($db);
         }
 
         $dsn = $db;
-        //$dsn = 'memory'; // Overwrite for fast tests
-        $pdo = new PDO("sqlite:" . $dsn, null, null, SQLite::getPDOAttributes());
+        // $dsn = 'memory'; // Overwrite for fast tests
+        $pdo = new PDO('sqlite:'.$dsn, null, null, SQLite::getPDOAttributes());
 
         $redis = new Redis();
         $redis->connect('redis');
-        $redis->flushAll();
+        $redis->select(10);
 
-        $cache = new Cache(new RedisAdapter($redis));
+        $cache = new Cache((new RedisAdapter($redis))->setMaxRetries(3));
 
         $adapter = new SQLite($pdo);
         $adapter->setEmulateMySQL(true);
 
         $database = new Database($adapter, $cache);
+        assert(self::$authorization !== null);
         $database
             ->setAuthorization(self::$authorization)
-            ->setDatabase('utopiaTests')
+            ->setDatabase($this->testDatabase)
             ->setSharedTables(true)
             ->setTenant(999)
-            ->setNamespace(static::$namespace = '');
+            ->setNamespace(static::$namespace = 'st_'.static::getTestToken().'_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -70,14 +68,16 @@ public function getDatabase(): Database
         $database->create();
 
         self::$pdo = $pdo;
+
         return self::$database = $database;
     }
 
     protected function deleteColumn(string $collection, string $column): bool
     {
-        $sqlTable = "`" . $this->getDatabase()->getNamespace() . "_" . $collection . "`";
+        $sqlTable = '`'.$this->getDatabase()->getNamespace().'_'.$collection.'`';
         $sql = "ALTER TABLE {$sqlTable} DROP COLUMN `{$column}`";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
@@ -85,9 +85,10 @@ protected function deleteColumn(string $collection, string $column): bool
 
     protected function deleteIndex(string $collection, string $index): bool
     {
-        $index = "`".$this->getDatabase()->getNamespace()."_".$this->getDatabase()->getTenant()."_{$collection}_{$index}`";
+        $index = '`'.$this->getDatabase()->getNamespace().'_'.$this->getDatabase()->getTenant()."_{$collection}_{$index}`";
         $sql = "DROP INDEX {$index}";
 
+        assert(self::$pdo !== null);
         self::$pdo->exec($sql);
 
         return true;
diff --git a/tests/e2e/Adapter/Support/EventRecorder.php b/tests/e2e/Adapter/Support/EventRecorder.php
new file mode 100644
index 0000000000..ab6493b15e
--- /dev/null
+++ b/tests/e2e/Adapter/Support/EventRecorder.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Tests\E2E\Adapter\Support;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Event;
+use Utopia\Database\Hook\Lifecycle;
+
+final class EventRecorder implements Lifecycle
+{
+    /** @var list<Event> */
+    private array $events;
+
+    /** @param list<Event> $events */
+    public function __construct(array $events, private readonly TestCase $test)
+    {
+        $this->events = $events;
+    }
+
+    public function handle(Event $event, mixed $data): void
+    {
+        $expected = \array_shift($this->events);
+
+        $this->test->assertSame($expected, $event);
+    }
+}
diff --git a/tests/unit/Adapter/AddTableColumnTest.php b/tests/unit/Adapter/AddTableColumnTest.php
new file mode 100644
index 0000000000..ef3ed4c97f
--- /dev/null
+++ b/tests/unit/Adapter/AddTableColumnTest.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use stdClass;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Query\Schema\Column;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\MySQL as MySQLSchema;
+use Utopia\Query\Schema\PostgreSQL as PostgreSQLSchema;
+use Utopia\Query\Schema\Table;
+
+final class AddTableColumnTest extends TestCase
+{
+    public function testVectorOnMySQLTableThrowsDatabaseException(): void
+    {
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Vector columns are only supported on PostgreSQL');
+
+        $this->addTableColumn((new MySQLSchema())->table('t'), 'embedding', ColumnType::Vector, 3);
+    }
+
+    public function testVectorOnPostgreSQLTableSetsTypeAndDimensions(): void
+    {
+        $size = 4;
+        $column = $this->addTableColumn((new PostgreSQLSchema())->table('t'), 'embedding', ColumnType::Vector, $size);
+
+        $this->assertSame(ColumnType::Vector, $column->type);
+        $this->assertSame($size, $column->dimensions);
+    }
+
+    public function testBigSerialOnMySQLTableIsAutoIncrement(): void
+    {
+        $column = $this->addTableColumn((new MySQLSchema())->table('t'), 'seq', ColumnType::BigSerial, 0);
+
+        $this->assertSame(ColumnType::BigSerial, $column->type);
+        $this->assertSame(true, $column->isAutoIncrement);
+    }
+
+    public function testBigSerialOnPostgreSQLTableIsAutoIncrement(): void
+    {
+        $column = $this->addTableColumn((new PostgreSQLSchema())->table('t'), 'seq', ColumnType::BigSerial, 0);
+
+        $this->assertSame(ColumnType::BigSerial, $column->type);
+        $this->assertSame(true, $column->isAutoIncrement);
+    }
+
+    public function testBigSerialOnBaseTableThrowsDatabaseException(): void
+    {
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Serial columns are not supported on this dialect');
+
+        $this->addTableColumn(new Table(), 'seq', ColumnType::BigSerial, 0);
+    }
+
+    private function addTableColumn(Table $table, string $id, ColumnType $type, int $size): Column
+    {
+        $adapter = new MariaDB(new stdClass());
+        $method = new ReflectionMethod(SQL::class, 'addTableColumn');
+        $column = $method->invoke($adapter, $table, $id, $type, $size);
+
+        if (! $column instanceof Column) {
+            $this->fail('addTableColumn did not return a Column');
+        }
+
+        return $column;
+    }
+}
diff --git a/tests/unit/Adapter/FeatureContractTest.php b/tests/unit/Adapter/FeatureContractTest.php
new file mode 100644
index 0000000000..f8dcd4e2ef
--- /dev/null
+++ b/tests/unit/Adapter/FeatureContractTest.php
@@ -0,0 +1,190 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Adapter\Pool;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Adapter\Redis;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Pools\Pool as UtopiaPool;
+
+final class FeatureContractTest extends TestCase
+{
+    public function testMemoryDoesNotAdvertiseOptionalEngineMethods(): void
+    {
+        $adapter = $this->instance(new Memory());
+
+        foreach ([
+            'rawQuery',
+            'rawMutation',
+            'getBuilder',
+            'getSchema',
+            'decodePoint',
+            'getColumnType',
+            'getSchemaAttributes',
+            'castingBefore',
+            'setUTCDatetime',
+            'setTimeout',
+            'upsertDocuments',
+            'getConnectionId',
+        ] as $method) {
+            $this->assertSame(false, \method_exists($adapter, $method), $method);
+        }
+
+        foreach (['createRelationship'] as $method) {
+            $this->assertSame(true, \method_exists($adapter, $method), $method);
+        }
+
+        $this->assertSame(true, $adapter instanceof Feature\Relationships);
+        $this->assertSame(false, $adapter instanceof Feature\Upserts);
+    }
+
+    public function testMemoryHasFeatureReportsRelationshipsButNotSpatial(): void
+    {
+        $adapter = $this->instance(new Memory());
+
+        $this->assertSame(false, $adapter->hasFeature(Feature\Spatial::class));
+        $this->assertSame(true, $adapter->hasFeature(Feature\Relationships::class));
+    }
+
+    public function testMemoryPoolHasFeatureDelegatesToInnerAdapter(): void
+    {
+        $adapter = new Memory();
+
+        /** @var UtopiaPool<Adapter>&Stub $connections */
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($adapter),
+        );
+
+        $pool = new Pool($connections);
+        $pool->setAuthorization(new Authorization());
+
+        $this->assertSame(false, $pool->hasFeature(Feature\Spatial::class));
+        $this->assertSame(true, $pool->hasFeature(Feature\Relationships::class));
+    }
+
+    public function testPoolDoesNotImplementOptionalFeatureInterfaces(): void
+    {
+        $implements = $this->interfaces(Pool::class);
+
+        foreach ([
+            Feature\ConnectionId::class,
+            Feature\InternalCasting::class,
+            Feature\Relationships::class,
+            Feature\SchemaAttributes::class,
+            Feature\SchemaIndexes::class,
+            Feature\Spatial::class,
+            Feature\Timeouts::class,
+            Feature\Upserts::class,
+            Feature\UTCCasting::class,
+            Feature\RawQuery::class,
+            Feature\QueryBuilder::class,
+            Feature\ColumnTypes::class,
+        ] as $feature) {
+            $this->assertArrayNotHasKey($feature, $implements, $feature);
+        }
+
+        foreach ([
+            'decodePoint',
+            'upsertDocuments',
+            'setTimeout',
+            'getConnectionId',
+            'rawQuery',
+            'getBuilder',
+            'getColumnType',
+            'castingBefore',
+            'setUTCDatetime',
+            'getSchemaAttributes',
+            'createRelationship',
+        ] as $method) {
+            $this->assertSame(true, \method_exists(Pool::class, $method), $method);
+        }
+    }
+
+    public function testRedisAdvertisesUpsertsConnectionIdAndRelationships(): void
+    {
+        $class = Redis::class;
+
+        foreach ([
+            'rawQuery',
+            'rawMutation',
+            'getBuilder',
+            'getSchema',
+            'decodePoint',
+            'getColumnType',
+            'getSchemaAttributes',
+            'castingBefore',
+            'setUTCDatetime',
+            'setTimeout',
+        ] as $method) {
+            $this->assertSame(false, \method_exists($class, $method), $method);
+        }
+
+        foreach (['upsertDocuments', 'getConnectionId'] as $method) {
+            $this->assertSame(true, \method_exists($class, $method), $method);
+        }
+
+        $implements = $this->interfaces($class);
+        $this->assertArrayHasKey(Feature\Upserts::class, $implements);
+        $this->assertArrayHasKey(Feature\ConnectionId::class, $implements);
+        $this->assertArrayHasKey(Feature\Relationships::class, $implements);
+    }
+
+    public function testSQLiteImplementsSqlFeaturesButNotSpatialTimeoutsOrConnectionId(): void
+    {
+        $implements = $this->interfaces(SQLite::class);
+        $this->assertArrayHasKey(Feature\Upserts::class, $implements);
+        $this->assertArrayHasKey(Feature\Relationships::class, $implements);
+        $this->assertArrayHasKey(Feature\SchemaAttributes::class, $implements);
+        $this->assertArrayHasKey(Feature\SchemaIndexes::class, $implements);
+        $this->assertArrayHasKey(Feature\RawQuery::class, $implements);
+        $this->assertArrayHasKey(Feature\QueryBuilder::class, $implements);
+        $this->assertArrayHasKey(Feature\ColumnTypes::class, $implements);
+        $this->assertArrayNotHasKey(Feature\Spatial::class, $implements);
+        $this->assertArrayNotHasKey(Feature\Timeouts::class, $implements);
+        $this->assertArrayNotHasKey(Feature\ConnectionId::class, $implements);
+    }
+
+    public function testMariaDBImplementsSpatialTimeoutsConnectionIdAndSchemaIndexes(): void
+    {
+        $implements = $this->interfaces(MariaDB::class);
+        $this->assertArrayHasKey(Feature\Spatial::class, $implements);
+        $this->assertArrayHasKey(Feature\Timeouts::class, $implements);
+        $this->assertArrayHasKey(Feature\ConnectionId::class, $implements);
+        $this->assertArrayHasKey(Feature\SchemaIndexes::class, $implements);
+    }
+
+    public function testPostgresImplementsSpatialTimeoutsAndConnectionIdWithoutSchemaIntrospection(): void
+    {
+        $implements = $this->interfaces(Postgres::class);
+        $this->assertArrayHasKey(Feature\Spatial::class, $implements);
+        $this->assertArrayHasKey(Feature\Timeouts::class, $implements);
+        $this->assertArrayHasKey(Feature\ConnectionId::class, $implements);
+        $this->assertArrayNotHasKey(Feature\SchemaAttributes::class, $implements);
+        $this->assertArrayNotHasKey(Feature\SchemaIndexes::class, $implements);
+    }
+
+    /**
+     * @param class-string $class
+     * @return array<string, string>
+     */
+    private function interfaces(string $class): array
+    {
+        $implements = \class_implements($class);
+
+        return $implements === false ? [] : $implements;
+    }
+
+    private function instance(Adapter $adapter): Adapter
+    {
+        return $adapter;
+    }
+}
diff --git a/tests/unit/Adapter/PoolTest.php b/tests/unit/Adapter/PoolTest.php
new file mode 100644
index 0000000000..202960e7b9
--- /dev/null
+++ b/tests/unit/Adapter/PoolTest.php
@@ -0,0 +1,270 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None as NoCache;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Adapter\Pool;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Hook\Permissions;
+use Utopia\Database\Hook\Tenancy;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Pools\Pool as UtopiaPool;
+
+final class PoolTest extends TestCase
+{
+    public function testDelegateReplacesStatefulWriteHookOnReusedAdapter(): void
+    {
+        $adapter = new Memory();
+        $adapter->addWriteHook(new Tenancy('old'));
+        $pool = $this->createPool($adapter);
+
+        $hook = new Tenancy('new');
+        $pool->addWriteHook($hook);
+
+        $this->assertTrue($pool->ping());
+        $this->assertSame([$hook], $adapter->getWriteHooks());
+        $this->assertSame([Storage::TENANT => 'new'], $adapter->getTenantHook()?->decorateRow([]));
+    }
+
+    public function testTransactionReplacesStatefulWriteHookOnReusedAdapter(): void
+    {
+        $adapter = new Memory();
+        $adapter->addWriteHook(new Permissions());
+        $adapter->addWriteHook(new Tenancy('old'));
+        $pool = $this->createPool($adapter);
+
+        $hook = new Tenancy('new');
+        $pool->addWriteHook($hook);
+
+        $pool->withTransaction(static fn (): string => 'committed');
+        $this->assertSame([$hook], $adapter->getWriteHooks());
+        $this->assertSame($hook, $adapter->getTenantHook());
+    }
+
+    public function testDelegateRemovesWriteHookRemovedFromPool(): void
+    {
+        $adapter = new Memory();
+        $pool = $this->createPool($adapter);
+
+        $hook = new Permissions();
+        $pool->addWriteHook($hook);
+        $this->assertTrue($pool->ping());
+        $this->assertSame([$hook], $adapter->getWriteHooks());
+
+        $pool->removeWriteHook(Permissions::class);
+        $this->assertTrue($pool->ping());
+        $this->assertSame([], $adapter->getWriteHooks());
+    }
+
+    public function testTransactionRemovesWriteHookRemovedFromPool(): void
+    {
+        $adapter = new Memory();
+        $pool = $this->createPool($adapter);
+
+        $hook = new Permissions();
+        $pool->addWriteHook($hook);
+        $pool->withTransaction(static fn (): string => 'committed');
+        $this->assertSame([$hook], $adapter->getWriteHooks());
+
+        $pool->removeWriteHook(Permissions::class);
+        $pool->withTransaction(static fn (): string => 'committed');
+        $this->assertSame([], $adapter->getWriteHooks());
+    }
+
+    public function testTransactionPropagatesWriteHooksToPinnedAdapter(): void
+    {
+        /** @var Adapter&MockObject $adapter */
+        $adapter = $this->createMock(Adapter::class);
+        $adapter->method('getWriteHooks')->willReturn([]);
+        $adapter->method('withTransaction')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback(),
+        );
+
+        $hook = new Permissions();
+        $adapter->expects($this->once())
+            ->method('addWriteHook')
+            ->with($this->identicalTo($hook))
+            ->willReturnSelf();
+
+        /** @var UtopiaPool<Adapter>&Stub $connections */
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($adapter),
+        );
+
+        $pool = new Pool($connections);
+        $pool->setAuthorization(new Authorization());
+        $pool->addWriteHook($hook);
+
+        $pool->withTransaction(static fn (): string => 'committed');
+    }
+
+    public function testPinnedAdapterResyncsTenantAndDatabaseBeforeDelegatedCall(): void
+    {
+        $adapter = new Memory();
+        $adapter->setDatabase('old_db');
+        $adapter->setNamespace('old_ns');
+        $adapter->setTenant(1);
+
+        $pool = $this->createPool($adapter);
+        $pool->setDatabase('old_db');
+        $pool->setNamespace('old_ns');
+        $pool->setTenant(1);
+
+        $pool->withTransaction(function () use ($pool, $adapter): void {
+            $pool->setDatabase('new_db');
+            $pool->setNamespace('new_ns');
+            $pool->setTenant(2);
+
+            $this->assertTrue($pool->ping());
+            $this->assertSame('new_db', $adapter->getDatabase());
+            $this->assertSame('new_ns', $adapter->getNamespace());
+            $this->assertSame(2, $adapter->getTenant());
+        });
+    }
+
+    public function testMemoryPoolPingDoesNotRequireTimeouts(): void
+    {
+        $pool = $this->createPool(new Memory());
+
+        $this->assertTrue($pool->ping());
+    }
+
+    /**
+     * A timeout is adapter state, so setting one must not check a connection out
+     * — a handle built against an unreachable backing would otherwise fail before
+     * the caller had issued a single query. The adapter's capabilities are first
+     * known when the timeout is applied, which is where the refusal belongs.
+     */
+    public function testMemoryPoolSetTimeoutRefusesWhenTheTimeoutWouldBeApplied(): void
+    {
+        $pool = $this->createPool(new Memory());
+
+        $pool->setTimeout(1000);
+        $this->assertSame(1000, $pool->getTimeout());
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Adapter does not support timeouts');
+
+        $pool->getDriver();
+    }
+
+    public function testMissingFeatureThrows(): void
+    {
+        $pool = $this->createPool(new Memory());
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Adapter does not support upserts');
+
+        $pool->upsertDocuments(new Document(), 'id', []);
+    }
+
+    /**
+     * Configuring a handle must not open a connection, or an unreachable
+     * backing fails a caller that has issued no query yet. Pool::setTimeout()
+     * holds the value without checking out, but Database::setTimeout() guarded
+     * itself with hasFeature(), and on a pool that guard is a delegated call --
+     * which dials.
+     */
+    public function testSettingATimeoutOnAPooledHandleDoesNotOpenAConnection(): void
+    {
+        $dials = 0;
+
+        /** @var UtopiaPool<Adapter>&Stub $connections */
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static function (callable $callback) use (&$dials): mixed {
+                $dials++;
+
+                return $callback(new Memory());
+            },
+        );
+
+        $pool = new Pool($connections);
+        $pool->setAuthorization(new Authorization());
+
+        (new Database($pool, new Cache(new NoCache())))->setTimeout(300000);
+
+        $this->assertSame(0, $dials, 'Building a handle must not check a connection out');
+        $this->assertSame(300000, $pool->getTimeout(), 'The handle must still hold the timeout it was given');
+    }
+
+    /**
+     * syncPinnedTimeouts() reaches whatever the handle has pinned. Upstream that
+     * is one adapter on the object, but a handle that pins per coroutine keeps
+     * its pins elsewhere, and reading the property directly reached none of
+     * them -- a timeout raised inside a transaction then arrived at the next
+     * checkout, long after the body it was meant to bound had run.
+     */
+    public function testTimeoutRaisedWhilePinnedReachesTheSubclassPin(): void
+    {
+        $pinned = new TimeoutRecordingAdapter();
+
+        /** @var UtopiaPool<Adapter>&Stub $connections */
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback(new TimeoutRecordingAdapter()),
+        );
+
+        $pool = new ElsewherePinnedPool($connections);
+        $pool->setAuthorization(new Authorization());
+        $pool->pinElsewhere($pinned);
+
+        $pool->setTimeout(300000);
+
+        $this->assertSame(300000, $pinned->getTimeout(), 'The connection the open transaction is running on must get the new bound');
+    }
+
+    private function createPool(Adapter $adapter): Pool
+    {
+        /** @var UtopiaPool<Adapter>&Stub $connections */
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($adapter),
+        );
+
+        $pool = new Pool($connections);
+        $pool->setAuthorization(new Authorization());
+
+        return $pool;
+    }
+}
+
+final class TimeoutRecordingAdapter extends Memory implements Feature\Timeouts
+{
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
+    {
+        $this->setTimeoutState($milliseconds, $event);
+    }
+
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        $this->clearTimeoutState($event);
+    }
+}
+
+final class ElsewherePinnedPool extends Pool
+{
+    private ?Adapter $elsewhere = null;
+
+    public function pinElsewhere(Adapter $adapter): void
+    {
+        $this->elsewhere = $adapter;
+    }
+
+    protected function pin(): ?Adapter
+    {
+        return $this->elsewhere;
+    }
+}
diff --git a/tests/unit/Adapter/ReadWritePoolTest.php b/tests/unit/Adapter/ReadWritePoolTest.php
new file mode 100644
index 0000000000..8c00215ea7
--- /dev/null
+++ b/tests/unit/Adapter/ReadWritePoolTest.php
@@ -0,0 +1,421 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Adapter\ReadWritePool;
+use Utopia\Database\Document;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Pools\Pool as UtopiaPool;
+
+#[AllowMockObjectsWithoutExpectations]
+class ReadWritePoolTest extends TestCase
+{
+    /** @var UtopiaPool<Adapter>&Stub */
+    private UtopiaPool $writePool;
+
+    /** @var UtopiaPool<Adapter>&Stub */
+    private UtopiaPool $readPool;
+
+    private ReadWritePool $pool;
+
+    /** @var FeatureAdapterStub&MockObject */
+    private Adapter $writeAdapter;
+
+    /** @var FeatureAdapterStub&MockObject */
+    private Adapter $readAdapter;
+
+    protected function setUp(): void
+    {
+        $this->writeAdapter = $this->createMock(FeatureAdapterStub::class);
+        $this->readAdapter = $this->createMock(FeatureAdapterStub::class);
+
+        $this->writePool = self::createStub(UtopiaPool::class);
+        $this->readPool = self::createStub(UtopiaPool::class);
+
+        $this->writePool->method('use')->willReturnCallback(function (callable $callback) {
+            return $callback($this->writeAdapter);
+        });
+
+        $this->readPool->method('use')->willReturnCallback(function (callable $callback) {
+            return $callback($this->readAdapter);
+        });
+
+        $this->pool = new ReadWritePool($this->writePool, $this->readPool);
+        $this->pool->setAuthorization(new Authorization());
+    }
+
+    public function testReadMethodsRouteToReadPool(): void
+    {
+        $readMethods = [
+            'find',
+            'getDocument',
+            'count',
+            'sum',
+            'exists',
+            'list',
+            'getSchemaAttributes',
+            'getSchemaIndexes',
+            'getBuilder',
+            'getSchema',
+            'rawQuery',
+            'getColumnType',
+            'decodePoint',
+            'decodeLinestring',
+            'decodePolygon',
+            'getSizeOfCollection',
+            'getSizeOfCollectionOnDisk',
+            'ping',
+            'getConnectionId',
+            'getDocumentSizeLimit',
+            'getAttributeWidth',
+            'getCountOfAttributes',
+            'getCountOfIndexes',
+            'getCountOfDefaultAttributes',
+            'getCountOfDefaultIndexes',
+            'getLimitForString',
+            'getLimitForInt',
+            'getLimitForBigInt',
+            'getLimitForAttributes',
+            'getLimitForIndexes',
+            'getMaxIndexLength',
+            'getMaxVarcharLength',
+            'getMaxUIDLength',
+            'getMinDateTime',
+            'getIdAttributeType',
+            'getKeywords',
+            'getInternalIndexesKeys',
+            'supports',
+            'capabilities',
+            'hasFeature',
+        ];
+
+        foreach ($readMethods as $method) {
+            $this->readAdapter->expects($this->atLeastOnce())
+                ->method($method)
+                ->willReturn($this->getDefaultReturnForMethod($method));
+        }
+
+        foreach ($readMethods as $method) {
+            $args = $this->getDefaultArgsForMethod($method);
+            $this->pool->delegate($method, $args);
+        }
+    }
+
+    public function testWriteMethodRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('createDocument')
+            ->willReturn(new Document());
+
+        $this->pool->delegate('createDocument', [new Document(), new Document()]);
+    }
+
+    public function testDeleteDocumentRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('deleteDocument')
+            ->willReturn(true);
+
+        $this->pool->delegate('deleteDocument', ['collection', 'id']);
+    }
+
+    public function testUpdateDocumentRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('updateDocument')
+            ->willReturn(new Document());
+
+        $this->pool->delegate('updateDocument', [new Document(), 'id', new Document(), false]);
+    }
+
+    public function testCreateCollectionRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('createCollection')
+            ->willReturn(true);
+
+        $this->pool->delegate('createCollection', ['testCollection', [], []]);
+    }
+
+    public function testStickyModeRoutesReadsToWritePoolAfterWrite(): void
+    {
+        $this->pool->setSticky(true);
+        $this->pool->setStickyDuration(5000);
+
+        $this->writeAdapter->expects($this->once())
+            ->method('createDocument')
+            ->willReturn(new Document());
+
+        $this->pool->delegate('createDocument', [new Document(), new Document()]);
+
+        $this->writeAdapter->expects($this->once())
+            ->method('find')
+            ->willReturn([]);
+
+        $result = $this->pool->delegate('find', [new Document(), [], 25, 0, [], [], [], \Utopia\Query\CursorDirection::After, \Utopia\Database\PermissionType::Read]);
+        $this->assertSame([], $result);
+    }
+
+    public function testStickyDurationExpiry(): void
+    {
+        $this->pool->setSticky(true);
+        $this->pool->setStickyDuration(1);
+
+        $this->writeAdapter->expects($this->once())
+            ->method('createDocument')
+            ->willReturn(new Document());
+
+        $this->pool->delegate('createDocument', [new Document(), new Document()]);
+
+        usleep(2000);
+
+        $this->readAdapter->expects($this->once())
+            ->method('ping')
+            ->willReturn(true);
+
+        $result = $this->pool->delegate('ping', []);
+        $this->assertTrue($result);
+    }
+
+    public function testStickyDisabledRoutesReadNormally(): void
+    {
+        $this->pool->setSticky(false);
+
+        $this->writeAdapter->expects($this->once())
+            ->method('createDocument')
+            ->willReturn(new Document());
+
+        $this->pool->delegate('createDocument', [new Document(), new Document()]);
+
+        $this->readAdapter->expects($this->once())
+            ->method('ping')
+            ->willReturn(true);
+
+        $result = $this->pool->delegate('ping', []);
+        $this->assertTrue($result);
+    }
+
+    public function testSetStickyDurationIsChainable(): void
+    {
+        $result = $this->pool->setStickyDuration(3000);
+        $this->assertSame($this->pool, $result);
+    }
+
+    public function testSetStickyIsChainable(): void
+    {
+        $result = $this->pool->setSticky(true);
+        $this->assertSame($this->pool, $result);
+    }
+
+    public function testReadAfterMultipleWritesStaysSticky(): void
+    {
+        $this->pool->setSticky(true);
+        $this->pool->setStickyDuration(5000);
+
+        $this->writeAdapter->method('createDocument')
+            ->willReturn(new Document());
+        $this->writeAdapter->method('deleteDocument')
+            ->willReturn(true);
+
+        $this->pool->delegate('createDocument', [new Document(), new Document()]);
+        $this->pool->delegate('deleteDocument', ['collection', 'id']);
+
+        $this->writeAdapter->expects($this->once())
+            ->method('ping')
+            ->willReturn(true);
+
+        $result = $this->pool->delegate('ping', []);
+        $this->assertTrue($result);
+    }
+
+    public function testReadBeforeAnyWriteGoesToReadPool(): void
+    {
+        $this->pool->setSticky(true);
+        $this->pool->setStickyDuration(5000);
+
+        $this->readAdapter->expects($this->once())
+            ->method('ping')
+            ->willReturn(true);
+
+        $result = $this->pool->delegate('ping', []);
+        $this->assertTrue($result);
+    }
+
+    public function testPinnedAdapterResyncsTenantAndDatabaseBeforeDelegatedCall(): void
+    {
+        $writeAdapter = new Memory();
+        $writeAdapter->setDatabase('old_db');
+        $writeAdapter->setNamespace('old_ns');
+        $writeAdapter->setTenant(1);
+
+        $readAdapter = new Memory();
+
+        $writePool = self::createStub(UtopiaPool::class);
+        $writePool->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($writeAdapter),
+        );
+
+        $readPool = self::createStub(UtopiaPool::class);
+        $readPool->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($readAdapter),
+        );
+
+        $pool = new ReadWritePool($writePool, $readPool);
+        $pool->setAuthorization(new Authorization());
+        $pool->setDatabase('old_db');
+        $pool->setNamespace('old_ns');
+        $pool->setTenant(1);
+
+        $pool->withTransaction(function () use ($pool, $writeAdapter): void {
+            $pool->setDatabase('new_db');
+            $pool->setNamespace('new_ns');
+            $pool->setTenant(2);
+
+            $this->assertTrue($pool->ping());
+            $this->assertSame('new_db', $writeAdapter->getDatabase());
+            $this->assertSame('new_ns', $writeAdapter->getNamespace());
+            $this->assertSame(2, $writeAdapter->getTenant());
+        });
+    }
+
+    public function testReadAdapterClearsStaleTimeout(): void
+    {
+        /** @var Adapter&Feature\Timeouts&MockObject $readAdapter */
+        $readAdapter = $this->createMock(FeatureAdapterStub::class);
+        $readAdapter->expects($this->once())
+            ->method('clearTimeout');
+        $readAdapter->expects($this->once())
+            ->method('ping')
+            ->willReturn(true);
+
+        $readPool = self::createStub(UtopiaPool::class);
+        $readPool->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($readAdapter),
+        );
+
+        $pool = new ReadWritePool($this->writePool, $readPool);
+        $pool->setAuthorization(new Authorization());
+
+        $this->assertTrue($pool->delegate('ping', []));
+    }
+
+    public function testNonReadNonStandardMethodGoesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('createAttribute')
+            ->willReturn(true);
+
+        $attr = new \Utopia\Database\Attribute(key: 'test', type: \Utopia\Query\Schema\ColumnType::String, size: 128);
+        $this->pool->delegate('createAttribute', ['collection', $attr]);
+    }
+
+    public function testCreateIndexRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('createIndex')
+            ->willReturn(true);
+
+        $index = new \Utopia\Database\Index(key: 'idx', type: \Utopia\Query\Schema\IndexType::Key, attributes: ['col']);
+        $this->pool->delegate('createIndex', ['collection', $index, [], []]);
+    }
+
+    public function testDeleteCollectionRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('deleteCollection')
+            ->willReturn(true);
+
+        $this->pool->delegate('deleteCollection', ['collection']);
+    }
+
+    public function testRawMutationRoutesToWritePool(): void
+    {
+        $this->writeAdapter->expects($this->once())
+            ->method('rawMutation')
+            ->willReturn(1);
+
+        $this->pool->delegate('rawMutation', ['UPDATE t SET a = 1', []]);
+    }
+
+    /**
+     * @return mixed
+     */
+    private function getDefaultReturnForMethod(string $method): mixed
+    {
+        return match ($method) {
+            'find', 'list' => [],
+            'getDocument' => new Document(),
+            'count', 'sum', 'getSizeOfCollection', 'getSizeOfCollectionOnDisk',
+            'getDocumentSizeLimit', 'getAttributeWidth', 'getCountOfAttributes',
+            'getCountOfIndexes', 'getCountOfDefaultAttributes', 'getCountOfDefaultIndexes',
+            'getLimitForString', 'getLimitForInt', 'getLimitForBigInt',
+            'getLimitForAttributes', 'getLimitForIndexes', 'getMaxIndexLength',
+            'getMaxVarcharLength', 'getMaxUIDLength' => 0,
+            'exists', 'ping', 'supports', 'hasFeature' => true,
+            'getConnectionId', 'getIdAttributeType' => 'string',
+            'getMinDateTime' => new \DateTime(),
+            'getSchemaAttributes', 'getSchemaIndexes', 'getKeywords',
+            'getInternalIndexesKeys', 'capabilities', 'decodePoint',
+            'decodeLinestring', 'decodePolygon' => [],
+            'getBuilder' => $this->createStub(\Utopia\Query\Builder::class),
+            'getSchema' => $this->createStub(\Utopia\Query\Schema::class),
+            'rawQuery' => [],
+            'getColumnType' => 'VARCHAR',
+            default => null,
+        };
+    }
+
+    /**
+     * @return array<mixed>
+     */
+    private function getDefaultArgsForMethod(string $method): array
+    {
+        return match ($method) {
+            'find' => [new Document(), [], 25, 0, [], [], [], \Utopia\Query\CursorDirection::After, \Utopia\Database\PermissionType::Read],
+            'getDocument' => [new Document(), 'id', [], false],
+            'count' => [new Document(), [], null],
+            'sum' => [new Document(), 'attr', [], null],
+            'exists' => ['db', null],
+            'list' => [],
+            'getSizeOfCollection', 'getSizeOfCollectionOnDisk' => ['collection'],
+            'ping' => [],
+            'getConnectionId' => [],
+            'getDocumentSizeLimit' => [],
+            'getAttributeWidth' => [new Document()],
+            'getCountOfAttributes' => [new Document()],
+            'getCountOfIndexes' => [new Document()],
+            'getLimitForString', 'getLimitForInt', 'getLimitForBigInt',
+            'getLimitForAttributes', 'getLimitForIndexes',
+            'getMaxIndexLength', 'getMaxVarcharLength',
+            'getMaxUIDLength' => [],
+            'getMinDateTime' => [],
+            'getIdAttributeType' => [],
+            'supports' => [\Utopia\Database\Capability::Index],
+            'hasFeature' => [Feature\Spatial::class],
+            'getSchemaAttributes', 'getSchemaIndexes', 'getBuilder' => ['collection'],
+            'rawQuery' => ['SELECT 1', []],
+            'getColumnType' => ['string', 255, true, false, false],
+            'decodePoint', 'decodeLinestring', 'decodePolygon' => ['wkb'],
+            default => [],
+        };
+    }
+}
+
+abstract class FeatureAdapterStub extends Adapter implements
+    Feature\ColumnTypes,
+    Feature\ConnectionId,
+    Feature\QueryBuilder,
+    Feature\RawQuery,
+    Feature\SchemaAttributes,
+    Feature\SchemaIndexes,
+    Feature\Spatial,
+    Feature\Timeouts
+{
+}
diff --git a/tests/unit/AttributeModelTest.php b/tests/unit/AttributeModelTest.php
new file mode 100644
index 0000000000..55e861076f
--- /dev/null
+++ b/tests/unit/AttributeModelTest.php
@@ -0,0 +1,385 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+use Utopia\Database\Attribute\Integer;
+use Utopia\Database\Attribute\StringType;
+use Utopia\Database\Document;
+use Utopia\Query\Schema\ColumnType;
+
+class AttributeModelTest extends TestCase
+{
+    public function testConstructorDefaults(): void
+    {
+        $attr = new Attribute();
+
+        $this->assertSame('', $attr->key);
+        $this->assertSame(ColumnType::String, $attr->type);
+        $this->assertSame(0, $attr->size);
+        $this->assertFalse($attr->required);
+        $this->assertNull($attr->default);
+        $this->assertTrue($attr->signed);
+        $this->assertFalse($attr->array);
+        $this->assertNull($attr->format);
+        $this->assertSame([], $attr->formatOptions);
+        $this->assertSame([], $attr->filters);
+        $this->assertNull($attr->status);
+        $this->assertNull($attr->options);
+    }
+
+    public function testConstructorWithAllValues(): void
+    {
+        $attr = Attribute::double(
+            key: 'score',
+            required: true,
+            default: 0.0,
+            format: 'number',
+            formatOptions: ['min' => 0, 'max' => 100],
+            filters: ['range'],
+            status: 'available',
+            options: ['precision' => 2],
+        );
+
+        $this->assertSame('score', $attr->key);
+        $this->assertSame(ColumnType::Double, $attr->type);
+        $this->assertSame(0, $attr->size);
+        $this->assertTrue($attr->required);
+        $this->assertSame(0.0, $attr->default);
+        $this->assertTrue($attr->signed);
+        $this->assertFalse($attr->array);
+        $this->assertSame('number', $attr->format);
+        $this->assertSame(['min' => 0, 'max' => 100], $attr->formatOptions);
+        $this->assertSame(['range'], $attr->filters);
+        $this->assertSame('available', $attr->status);
+        $this->assertSame(['precision' => 2], $attr->options);
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $attr = Attribute::string(
+            key: 'email',
+            size: 256,
+            required: true,
+            format: 'email',
+            formatOptions: ['allowPlus' => true],
+            filters: ['lowercase'],
+        );
+
+        $doc = $attr->toDocument();
+
+        $this->assertSame('email', $doc->getId());
+        $this->assertSame('email', $doc->getAttribute('key'));
+        $this->assertSame('string', $doc->getAttribute('type'));
+        $this->assertSame(256, $doc->getAttribute('size'));
+        $this->assertTrue($doc->getAttribute('required'));
+        $this->assertNull($doc->getAttribute('default'));
+        $this->assertTrue($doc->getAttribute('signed'));
+        $this->assertFalse($doc->getAttribute('array'));
+        $this->assertSame('email', $doc->getAttribute('format'));
+        $this->assertSame(['allowPlus' => true], $doc->getAttribute('formatOptions'));
+        $this->assertSame(['lowercase'], $doc->getAttribute('filters'));
+    }
+
+    public function testToDocumentIncludesStatusWhenSet(): void
+    {
+        $attr = Attribute::string(key: 'name', size: 0, status: 'processing');
+
+        $doc = $attr->toDocument();
+        $this->assertSame('processing', $doc->getAttribute('status'));
+    }
+
+    public function testToDocumentExcludesStatusWhenNull(): void
+    {
+        $attr = Attribute::string(key: 'name', size: 0);
+
+        $doc = $attr->toDocument();
+        $this->assertNull($doc->getAttribute('status'));
+    }
+
+    public function testToDocumentIncludesOptionsWhenSet(): void
+    {
+        $options = [
+            'relatedCollection' => 'users',
+            'relationType' => 'oneToMany',
+            'twoWay' => true,
+            'twoWayKey' => 'posts',
+        ];
+        $attr = Attribute::relationship(key: 'author', options: $options);
+
+        $doc = $attr->toDocument();
+        $this->assertSame($options, $doc->getAttribute('options'));
+    }
+
+    public function testToDocumentExcludesOptionsWhenNull(): void
+    {
+        $attr = Attribute::string(key: 'name', size: 0);
+
+        $doc = $attr->toDocument();
+        $this->assertNull($doc->getAttribute('options'));
+    }
+
+    public function testArrayAccessMatchesDocumentShape(): void
+    {
+        $attr = Attribute::string(key: 'title', size: 128, required: true, status: 'available');
+
+        $this->assertSame('title', $attr['$id']);
+        $this->assertSame('title', $attr['key']);
+        $this->assertSame(ColumnType::String->value, $attr['type']);
+        $this->assertSame(128, $attr['size']);
+        $this->assertTrue($attr['required']);
+        $this->assertSame('available', $attr['status']);
+        $this->assertSame('title', $attr->getId());
+        $this->assertSame(ColumnType::String->value, $attr->getAttribute('type'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $original = Attribute::string(key: 'tags', size: 64, array: true, filters: ['json']);
+
+        $doc = $original->toDocument();
+        $restored = Attribute::fromDocument($doc);
+
+        $this->assertSame($original->key, $restored->key);
+        $this->assertSame($original->type, $restored->type);
+        $this->assertSame($original->size, $restored->size);
+        $this->assertSame($original->required, $restored->required);
+        $this->assertSame($original->default, $restored->default);
+        $this->assertSame($original->signed, $restored->signed);
+        $this->assertSame($original->array, $restored->array);
+        $this->assertSame($original->format, $restored->format);
+        $this->assertSame($original->formatOptions, $restored->formatOptions);
+        $this->assertSame($original->filters, $restored->filters);
+    }
+
+    public function testFromDocumentWithMinimalDocument(): void
+    {
+        $doc = new Document(['$id' => 'name']);
+        $attr = Attribute::fromDocument($doc);
+
+        $this->assertSame('name', $attr->key);
+        $this->assertSame(ColumnType::String, $attr->type);
+        $this->assertSame(0, $attr->size);
+        $this->assertFalse($attr->required);
+        $this->assertTrue($attr->signed);
+        $this->assertFalse($attr->array);
+    }
+
+    public function testFromDocumentUsesKeyOverId(): void
+    {
+        $doc = new Document(['$id' => 'id_val', 'key' => 'key_val', 'type' => 'string']);
+        $attr = Attribute::fromDocument($doc);
+
+        $this->assertSame('key_val', $attr->key);
+    }
+
+    public function testFromDocumentFallsBackToId(): void
+    {
+        $doc = new Document(['$id' => 'my_attr', 'type' => 'integer']);
+        $attr = Attribute::fromDocument($doc);
+
+        $this->assertSame('my_attr', $attr->key);
+    }
+
+    public function testFromArray(): void
+    {
+        $data = [
+            'key' => 'amount',
+            'type' => 'double',
+            'size' => 0,
+            'required' => true,
+            'default' => 0.0,
+            'signed' => true,
+            'array' => false,
+            'format' => null,
+            'formatOptions' => [],
+            'filters' => [],
+        ];
+
+        $attr = Attribute::fromArray($data);
+
+        $this->assertSame('amount', $attr->key);
+        $this->assertSame(ColumnType::Double, $attr->type);
+        $this->assertTrue($attr->required);
+        $this->assertSame(0.0, $attr->default);
+    }
+
+    public function testFromArrayWithIdFallback(): void
+    {
+        $data = ['$id' => 'my_field', 'type' => 'boolean'];
+        $attr = Attribute::fromArray($data);
+
+        $this->assertSame('my_field', $attr->key);
+        $this->assertSame(ColumnType::Boolean, $attr->type);
+    }
+
+    public function testFromArrayDefaults(): void
+    {
+        $data = ['type' => 'integer'];
+        $attr = Attribute::fromArray($data);
+
+        $this->assertSame('', $attr->key);
+        $this->assertSame(ColumnType::Integer, $attr->type);
+        $this->assertSame(0, $attr->size);
+        $this->assertFalse($attr->required);
+        $this->assertNull($attr->default);
+        $this->assertTrue($attr->signed);
+        $this->assertFalse($attr->array);
+        $this->assertNull($attr->format);
+        $this->assertSame([], $attr->formatOptions);
+        $this->assertSame([], $attr->filters);
+    }
+
+    public function testAllColumnTypeValues(): void
+    {
+        $typesToTest = [
+            ColumnType::String,
+            ColumnType::Varchar,
+            ColumnType::Text,
+            ColumnType::MediumText,
+            ColumnType::LongText,
+            ColumnType::Integer,
+            ColumnType::Double,
+            ColumnType::Boolean,
+            ColumnType::Datetime,
+            ColumnType::Relationship,
+            ColumnType::Point,
+            ColumnType::Linestring,
+            ColumnType::Polygon,
+            ColumnType::Vector,
+            ColumnType::Object,
+        ];
+
+        foreach ($typesToTest as $type) {
+            $attr = new Attribute(key: 'test_' . $type->value, type: $type);
+            $doc = $attr->toDocument();
+            $restored = Attribute::fromDocument($doc);
+
+            $this->assertSame($type, $restored->type, "Roundtrip failed for type: {$type->value}");
+        }
+    }
+
+    public function testWithFormatAndFormatOptions(): void
+    {
+        $attr = Attribute::string(key: 'url', size: 2048, format: 'url', formatOptions: ['allowedSchemes' => ['http', 'https']]);
+
+        $doc = $attr->toDocument();
+        $this->assertSame('url', $doc->getAttribute('format'));
+        $this->assertSame(['allowedSchemes' => ['http', 'https']], $doc->getAttribute('formatOptions'));
+
+        $restored = Attribute::fromDocument($doc);
+        $this->assertSame('url', $restored->format);
+        $this->assertSame(['allowedSchemes' => ['http', 'https']], $restored->formatOptions);
+    }
+
+    public function testWithFilters(): void
+    {
+        $attr = Attribute::string(key: 'content', size: 65535, filters: ['json', 'encrypt']);
+
+        $doc = $attr->toDocument();
+        $this->assertSame(['json', 'encrypt'], $doc->getAttribute('filters'));
+
+        $restored = Attribute::fromDocument($doc);
+        $this->assertSame(['json', 'encrypt'], $restored->filters);
+    }
+
+    public function testWithRelationshipOptions(): void
+    {
+        $options = [
+            'relatedCollection' => 'comments',
+            'relationType' => 'oneToMany',
+            'twoWay' => true,
+            'twoWayKey' => 'post',
+            'onDelete' => 'cascade',
+            'side' => 'parent',
+        ];
+
+        $attr = Attribute::relationship(key: 'comments', options: $options);
+
+        $doc = $attr->toDocument();
+        $restored = Attribute::fromDocument($doc);
+
+        $this->assertSame($options, $restored->options);
+    }
+
+    public function testWithDefaultValueTypes(): void
+    {
+        $stringAttr = Attribute::string(key: 's', size: 32, default: 'hello');
+        $this->assertSame('hello', $stringAttr->default);
+
+        $intAttr = Attribute::integer(key: 'i', default: 42);
+        $this->assertSame(42, $intAttr->default);
+
+        $boolAttr = Attribute::boolean(key: 'b', default: true);
+        $this->assertTrue($boolAttr->default);
+
+        $doubleAttr = Attribute::double(key: 'd', default: 3.14);
+        $this->assertSame(3.14, $doubleAttr->default);
+
+        $nullAttr = Attribute::string(key: 'n', size: 32);
+        $this->assertNull($nullAttr->default);
+    }
+
+    public function testFromArrayWithColumnTypeInstance(): void
+    {
+        $data = [
+            'key' => 'test',
+            'type' => ColumnType::Integer,
+            'size' => 0,
+        ];
+
+        $attr = Attribute::fromArray($data);
+        $this->assertSame(ColumnType::Integer, $attr->type);
+    }
+
+    public function testFromDocumentWithColumnTypeInstance(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'key' => 'test',
+            'type' => ColumnType::Boolean,
+        ]);
+
+        $attr = Attribute::fromDocument($doc);
+        $this->assertSame(ColumnType::Boolean, $attr->type);
+    }
+
+    public function testFromDocumentReturnsStringType(): void
+    {
+        $doc = new Document([
+            '$id' => 'name',
+            'key' => 'name',
+            'type' => 'string',
+        ]);
+
+        $attr = Attribute::fromDocument($doc);
+
+        $this->assertInstanceOf(StringType::class, $attr);
+    }
+
+    public function testFromArrayReturnsInteger(): void
+    {
+        $attr = Attribute::fromArray(['type' => 'integer']);
+
+        $this->assertInstanceOf(Integer::class, $attr);
+    }
+
+    public function testSubclassDefaultValues(): void
+    {
+        $stringAttr = Attribute::string(key: 's', size: 32, default: 'hello');
+        $this->assertSame('hello', $stringAttr->default);
+
+        $intAttr = Attribute::integer(key: 'i', default: 42);
+        $this->assertSame(42, $intAttr->default);
+
+        $boolAttr = Attribute::boolean(key: 'b', default: true);
+        $this->assertSame(true, $boolAttr->default);
+
+        $doubleAttr = Attribute::double(key: 'd', default: 3.14);
+        $this->assertSame(3.14, $doubleAttr->default);
+
+        $nullAttr = Attribute::string(key: 'n', size: 32, default: null);
+        $this->assertSame(null, $nullAttr->default);
+    }
+}
diff --git a/tests/unit/AttributeSubclassTest.php b/tests/unit/AttributeSubclassTest.php
new file mode 100644
index 0000000000..50d4d6a894
--- /dev/null
+++ b/tests/unit/AttributeSubclassTest.php
@@ -0,0 +1,412 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use ReflectionParameter;
+use Utopia\Cache\Adapter\None as NoneAdapter;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Attribute\ArrayType;
+use Utopia\Database\Attribute\BigInteger;
+use Utopia\Database\Attribute\BigSerial;
+use Utopia\Database\Attribute\Binary;
+use Utopia\Database\Attribute\Boolean;
+use Utopia\Database\Attribute\Datetime;
+use Utopia\Database\Attribute\Decimal;
+use Utopia\Database\Attribute\Double;
+use Utopia\Database\Attribute\EnumType;
+use Utopia\Database\Attribute\FloatType;
+use Utopia\Database\Attribute\Id;
+use Utopia\Database\Attribute\Integer;
+use Utopia\Database\Attribute\Json;
+use Utopia\Database\Attribute\Linestring;
+use Utopia\Database\Attribute\LongText;
+use Utopia\Database\Attribute\MediumText;
+use Utopia\Database\Attribute\ObjectType;
+use Utopia\Database\Attribute\Point;
+use Utopia\Database\Attribute\Polygon;
+use Utopia\Database\Attribute\Relationship;
+use Utopia\Database\Attribute\Serial;
+use Utopia\Database\Attribute\SmallInteger;
+use Utopia\Database\Attribute\SmallSerial;
+use Utopia\Database\Attribute\StringType;
+use Utopia\Database\Attribute\Text;
+use Utopia\Database\Attribute\Timestamp;
+use Utopia\Database\Attribute\TinyInteger;
+use Utopia\Database\Attribute\Tuple;
+use Utopia\Database\Attribute\Uuid;
+use Utopia\Database\Attribute\Uuid7;
+use Utopia\Database\Attribute\Varchar;
+use Utopia\Database\Attribute\Vector;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Query\Schema\ColumnType;
+
+final class AttributeSubclassTest extends TestCase
+{
+    /**
+     * @return array<string, array{class-string<Attribute>, string, ColumnType, int}>
+     */
+    public static function types(): array
+    {
+        return [
+            'string' => [StringType::class, 'string', ColumnType::String, Database::LENGTH_KEY],
+            'varchar' => [Varchar::class, 'varchar', ColumnType::Varchar, Database::LENGTH_KEY],
+            'text' => [Text::class, 'text', ColumnType::Text, 0],
+            'mediumText' => [MediumText::class, 'mediumText', ColumnType::MediumText, 0],
+            'longText' => [LongText::class, 'longText', ColumnType::LongText, 0],
+            'tinyInteger' => [TinyInteger::class, 'tinyInteger', ColumnType::TinyInteger, 0],
+            'smallInteger' => [SmallInteger::class, 'smallInteger', ColumnType::SmallInteger, 0],
+            'integer' => [Integer::class, 'integer', ColumnType::Integer, 0],
+            'bigInteger' => [BigInteger::class, 'bigInteger', ColumnType::BigInteger, 0],
+            'float' => [FloatType::class, 'float', ColumnType::Float, 0],
+            'double' => [Double::class, 'double', ColumnType::Double, 0],
+            'decimal' => [Decimal::class, 'decimal', ColumnType::Decimal, 0],
+            'boolean' => [Boolean::class, 'boolean', ColumnType::Boolean, 0],
+            'datetime' => [Datetime::class, 'datetime', ColumnType::Datetime, 0],
+            'timestamp' => [Timestamp::class, 'timestamp', ColumnType::Timestamp, 0],
+            'json' => [Json::class, 'json', ColumnType::Json, 0],
+            'binary' => [Binary::class, 'binary', ColumnType::Binary, 0],
+            'enum' => [EnumType::class, 'enum', ColumnType::Enum, 0],
+            'point' => [Point::class, 'point', ColumnType::Point, 0],
+            'linestring' => [Linestring::class, 'linestring', ColumnType::Linestring, 0],
+            'polygon' => [Polygon::class, 'polygon', ColumnType::Polygon, 0],
+            'vector' => [Vector::class, 'vector', ColumnType::Vector, 0],
+            'id' => [Id::class, 'id', ColumnType::Id, 0],
+            'uuid' => [Uuid::class, 'uuid', ColumnType::Uuid, 0],
+            'uuid7' => [Uuid7::class, 'uuid7', ColumnType::Uuid7, 0],
+            'object' => [ObjectType::class, 'object', ColumnType::Object, 0],
+            'relationship' => [Relationship::class, 'relationship', ColumnType::Relationship, 0],
+            'serial' => [Serial::class, 'serial', ColumnType::Serial, 0],
+            'bigSerial' => [BigSerial::class, 'bigSerial', ColumnType::BigSerial, 0],
+            'smallSerial' => [SmallSerial::class, 'smallSerial', ColumnType::SmallSerial, 0],
+            'array' => [ArrayType::class, 'array', ColumnType::Array, 0],
+            'tuple' => [Tuple::class, 'tuple', ColumnType::Tuple, 0],
+        ];
+    }
+
+    /**
+     * @param class-string<Attribute> $class
+     */
+    #[DataProvider('types')]
+    public function testFactoryAndSubclassDefaults(
+        string $class,
+        string $factory,
+        ColumnType $type,
+        int $defaultSize,
+    ): void {
+        $fromFactory = Attribute::{$factory}(key: 'x');
+        $this->assertInstanceOf($class, $fromFactory);
+        $this->assertSame($type, $fromFactory->type);
+        $this->assertSame($defaultSize, $fromFactory->size);
+        $this->assertSame('x', $fromFactory->key);
+
+        $fromConstructor = new $class(key: 'x');
+        $this->assertInstanceOf($class, $fromConstructor);
+        $this->assertSame($type, $fromConstructor->type);
+        $this->assertSame($defaultSize, $fromConstructor->size);
+        $this->assertSame('x', $fromConstructor->key);
+    }
+
+    public function testStringFactoryOmitsTypeAndUsesLengthKey(): void
+    {
+        $attribute = Attribute::string(key: 'name');
+
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(Database::LENGTH_KEY, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+        $this->assertSame(false, in_array('type', $this->parameterNames(Attribute::class, 'string'), true));
+    }
+
+    public function testStringTypeConstructorUsesLengthKey(): void
+    {
+        $attribute = new StringType(key: 'name');
+
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(Database::LENGTH_KEY, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+        $this->assertSame(false, in_array('type', $this->parameterNames(StringType::class, '__construct'), true));
+    }
+
+    public function testIntegerConstructorOmitsType(): void
+    {
+        $attribute = new Integer(key: 'age', default: 0);
+
+        $this->assertSame(ColumnType::Integer, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame(0, $attribute->default);
+        $this->assertSame('age', $attribute->key);
+        $this->assertSame(false, in_array('type', $this->parameterNames(Integer::class, '__construct'), true));
+    }
+
+    public function testIntegerFactory(): void
+    {
+        $attribute = Attribute::integer(key: 'age', default: 0);
+
+        $this->assertSame(ColumnType::Integer, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame(0, $attribute->default);
+        $this->assertSame('age', $attribute->key);
+        $this->assertSame(false, in_array('type', $this->parameterNames(Attribute::class, 'integer'), true));
+    }
+
+    public function testVectorKeepsExplicitSize(): void
+    {
+        $fromFactory = Attribute::vector(key: 'embedding', size: 3);
+        $this->assertSame(ColumnType::Vector, $fromFactory->type);
+        $this->assertSame(3, $fromFactory->size);
+        $this->assertSame('embedding', $fromFactory->key);
+
+        $fromConstructor = new Vector(key: 'embedding', size: 3);
+        $this->assertSame(ColumnType::Vector, $fromConstructor->type);
+        $this->assertSame(3, $fromConstructor->size);
+        $this->assertSame('embedding', $fromConstructor->key);
+    }
+
+    public function testRelationshipStoresOptions(): void
+    {
+        $options = [
+            'relatedCollection' => 'users',
+            'relationType' => 'oneToMany',
+            'twoWay' => true,
+            'twoWayKey' => 'posts',
+        ];
+
+        $attribute = Attribute::relationship(key: 'author', options: $options);
+
+        $this->assertSame(ColumnType::Relationship, $attribute->type);
+        $this->assertSame($options, $attribute->options);
+        $this->assertSame('author', $attribute->key);
+        $this->assertSame(0, $attribute->size);
+    }
+
+    /**
+     * @param class-string<Attribute> $class
+     */
+    #[DataProvider('types')]
+    public function testFromDocumentReturnsSubclass(
+        string $class,
+        string $_factory,
+        ColumnType $type,
+        int $_defaultSize,
+    ): void {
+        $attribute = Attribute::fromDocument(new Document([
+            'key' => 'x',
+            'type' => $type->value,
+        ]));
+
+        $this->assertInstanceOf($class, $attribute);
+        $this->assertSame($type, $attribute->type);
+        $this->assertSame('x', $attribute->key);
+    }
+
+    /**
+     * @param class-string<Attribute> $class
+     */
+    #[DataProvider('types')]
+    public function testFromArrayReturnsSubclass(
+        string $class,
+        string $_factory,
+        ColumnType $type,
+        int $_defaultSize,
+    ): void {
+        $attribute = Attribute::fromArray([
+            'key' => 'x',
+            'type' => $type->value,
+        ]);
+
+        $this->assertInstanceOf($class, $attribute);
+        $this->assertSame($type, $attribute->type);
+        $this->assertSame('x', $attribute->key);
+    }
+
+    public function testFromDocumentPreservesStoredSizeZero(): void
+    {
+        $attribute = Attribute::fromDocument(new Document([
+            'key' => 'name',
+            'type' => ColumnType::String->value,
+            'size' => 0,
+        ]));
+
+        $this->assertInstanceOf(StringType::class, $attribute);
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+    }
+
+    public function testFromArrayPreservesStoredSizeZero(): void
+    {
+        $attribute = Attribute::fromArray([
+            'key' => 'name',
+            'type' => ColumnType::String->value,
+            'size' => 0,
+        ]);
+
+        $this->assertInstanceOf(StringType::class, $attribute);
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+    }
+
+    /**
+     * @param class-string<Attribute> $class
+     */
+    #[DataProvider('types')]
+    public function testCreateDocumentInstanceHydratesMappedSubclass(
+        string $class,
+        string $_factory,
+        ColumnType $type,
+        int $_defaultSize,
+    ): void {
+        $database = $this->database();
+        $database->setDocumentType('schema', $class);
+
+        $document = $this->instantiate($database, 'schema', [
+            '$id' => 'x',
+            'key' => 'x',
+            'type' => $type->value,
+        ]);
+
+        $this->assertInstanceOf($class, $document);
+        $this->assertSame($type, $document->type);
+        $this->assertSame('x', $document->key);
+    }
+
+    /**
+     * @param class-string<Attribute> $class
+     */
+    #[DataProvider('types')]
+    public function testCreateDocumentInstanceHydratesSubclassFromAttributeType(
+        string $class,
+        string $_factory,
+        ColumnType $type,
+        int $_defaultSize,
+    ): void {
+        $database = $this->database();
+        $database->setDocumentType('schema', Attribute::class);
+
+        $document = $this->instantiate($database, 'schema', [
+            '$id' => 'x',
+            'key' => 'x',
+            'type' => $type->value,
+        ]);
+
+        $this->assertInstanceOf($class, $document);
+        $this->assertSame($type, $document->type);
+        $this->assertSame('x', $document->key);
+    }
+
+    public function testCreateDocumentInstanceUsesStoredTypeNotMappedClass(): void
+    {
+        $database = $this->database();
+        $database->setDocumentType('schema', StringType::class);
+
+        $document = $this->instantiate($database, 'schema', [
+            '$id' => 'age',
+            'key' => 'age',
+            'type' => ColumnType::Integer->value,
+        ]);
+
+        $this->assertInstanceOf(Integer::class, $document);
+    }
+
+    public function testFromDocumentMissingSizeIsZero(): void
+    {
+        $attribute = Attribute::fromDocument(new Document([
+            'key' => 'name',
+            'type' => ColumnType::String->value,
+        ]));
+
+        $this->assertInstanceOf(StringType::class, $attribute);
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+    }
+
+    public function testLegacyBigintHydratesToBigInteger(): void
+    {
+        $attribute = Attribute::fromDocument(new Document([
+            'key' => 'count',
+            'type' => Attribute::LEGACY_BIG_INTEGER,
+        ]));
+
+        $this->assertInstanceOf(BigInteger::class, $attribute);
+        $this->assertSame(ColumnType::BigInteger, $attribute->type);
+        $this->assertSame('count', $attribute->key);
+    }
+
+    public function testBaseConstructorIsNotASubclass(): void
+    {
+        $attribute = new Attribute(key: 'name', type: ColumnType::String, size: Database::LENGTH_KEY);
+
+        $this->assertSame(Attribute::class, $attribute::class);
+        $this->assertSame(ColumnType::String, $attribute->type);
+        $this->assertSame(Database::LENGTH_KEY, $attribute->size);
+        $this->assertSame('name', $attribute->key);
+    }
+
+    public function testStringRoundTrip(): void
+    {
+        $original = Attribute::string(key: 'email', size: 256, required: true);
+        $restored = Attribute::fromDocument($original->toDocument());
+
+        $this->assertInstanceOf(StringType::class, $restored);
+        $this->assertSame($original->key, $restored->key);
+        $this->assertSame($original->size, $restored->size);
+        $this->assertSame($original->required, $restored->required);
+        $this->assertSame($original->type, $restored->type);
+        $this->assertSame(256, $restored->size);
+        $this->assertSame(true, $restored->required);
+    }
+
+    public function testEnumAndArrayAreSubclasses(): void
+    {
+        $enum = Attribute::enum(key: 'status');
+        $array = Attribute::array(key: 'tags');
+
+        $this->assertSame(ColumnType::Enum, $enum->type);
+        $this->assertSame('status', $enum->key);
+        $this->assertSame(0, $enum->size);
+
+        $this->assertSame(ColumnType::Array, $array->type);
+        $this->assertSame('tags', $array->key);
+        $this->assertSame(0, $array->size);
+    }
+
+    /**
+     * @param class-string $class
+     * @return array<int, string>
+     */
+    private function parameterNames(string $class, string $method): array
+    {
+        return array_map(
+            static fn (ReflectionParameter $parameter): string => $parameter->getName(),
+            (new ReflectionMethod($class, $method))->getParameters(),
+        );
+    }
+
+    private function database(): Database
+    {
+        return new Database(
+            $this->createStub(Adapter::class),
+            new Cache(new NoneAdapter()),
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    private function instantiate(Database $database, string $collection, array $data): Document
+    {
+        $method = new ReflectionMethod(Database::class, 'createDocumentInstance');
+
+        /** @var Document $document */
+        $document = $method->invoke($database, $collection, $data);
+
+        return $document;
+    }
+}
diff --git a/tests/unit/Attributes/AttributeValidationTest.php b/tests/unit/Attributes/AttributeValidationTest.php
new file mode 100644
index 0000000000..8109df0d01
--- /dev/null
+++ b/tests/unit/Attributes/AttributeValidationTest.php
@@ -0,0 +1,376 @@
+<?php
+
+namespace Tests\Unit\Attributes;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class AttributeValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createAttribute')->willReturn(true);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     */
+    private function setupCollection(string $id, array $attributes = []): void
+    {
+        $collection = new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $meta = $this->metaCollection();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($id, $collection, $meta) {
+                if ($col->getId() === Database::METADATA && $docId === $id) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+    }
+
+    public function testCreateAttributeOnMissingCollectionThrows(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+
+        $this->expectException(NotFoundException::class);
+        $this->database->createAttribute('nonexistent', Attribute::string(key: 'name', size: 128));
+    }
+
+    public function testCreateAttributeRejectsDuplicateKey(): void
+    {
+        $existingAttrs = [
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $existingAttrs);
+
+        $this->expectException(DuplicateException::class);
+        $this->database->createAttribute('testCol', Attribute::string(key: 'title', size: 128));
+    }
+
+    public function testCreateAttributeValidatesSizeLimitsForStrings(): void
+    {
+        $this->setupCollection('testCol');
+
+        $this->expectException(\Utopia\Database\Exception::class);
+        $this->expectExceptionMessage('Max size allowed for string');
+
+        $tooBig = $this->adapter->getLimitForString() + 1;
+        $this->database->createAttribute('testCol', Attribute::string(key: 'bigstr', size: $tooBig));
+    }
+
+    public function testCreateAttributeSucceedsWithValidString(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', Attribute::string(key: 'name', size: 128));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithInteger(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', Attribute::integer(key: 'age'));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithBoolean(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', Attribute::boolean(key: 'active'));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithDouble(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', Attribute::double(key: 'score'));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeEnforcesAttributeCountLimit(): void
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(2);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(100);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [Capability::Index, Capability::IndexArray, Capability::UniqueIndex, Capability::DefinedAttributes]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('createAttribute')->willReturn(true);
+
+        $collection = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            'name' => 'testCol',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+        $adapter->method('updateDocument')->willReturnArgument(2);
+
+        $db = new Database($adapter, new Cache(new None()));
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        $this->expectException(LimitException::class);
+        $db->createAttribute('testCol', Attribute::string(key: 'extra', size: 128));
+    }
+
+    public function testCreateAttributeEnforcesRowWidthLimit(): void
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(100);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(200);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [Capability::Index, Capability::IndexArray, Capability::UniqueIndex, Capability::DefinedAttributes]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('createAttribute')->willReturn(true);
+
+        $collection = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            'name' => 'testCol',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+        $adapter->method('updateDocument')->willReturnArgument(2);
+
+        $db = new Database($adapter, new Cache(new None()));
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        $this->expectException(LimitException::class);
+        $db->createAttribute('testCol', Attribute::string(key: 'wide', size: 128));
+    }
+
+    public function testDeleteAttributeRemovesFromCollection(): void
+    {
+        $existingAttrs = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $existingAttrs);
+        $this->adapter->method('deleteAttribute')->willReturn(true);
+
+        $result = $this->database->deleteAttribute('testCol', 'name');
+        $this->assertTrue($result);
+    }
+
+    public function testDeleteAttributeThrowsOnNotFound(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(NotFoundException::class);
+        $this->database->deleteAttribute('testCol', 'nonexistent');
+    }
+
+    public function testRenameAttributeThrowsOnDuplicateName(): void
+    {
+        $existingAttrs = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $existingAttrs);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Attribute name already used');
+        $this->database->renameAttribute('testCol', 'name', 'title');
+    }
+
+    public function testRenameAttributeThrowsOnNotFound(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(NotFoundException::class);
+        $this->database->renameAttribute('testCol', 'nonexistent', 'newname');
+    }
+
+    public function testCreateAttributesBatchValidatesEach(): void
+    {
+        $existingAttrs = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $existingAttrs);
+        $this->adapter->method('createAttributes')->willReturn(true);
+
+        $this->expectException(DuplicateException::class);
+        $this->database->createAttributes('testCol', [
+            Attribute::string(key: 'name', size: 128),
+        ]);
+    }
+
+    public function testCreateAttributesBatchWithEmptyListThrows(): void
+    {
+        $this->setupCollection('testCol');
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('No attributes to create');
+        $this->database->createAttributes('testCol', []);
+    }
+}
diff --git a/tests/unit/Authorization/AuthorizationTest.php b/tests/unit/Authorization/AuthorizationTest.php
new file mode 100644
index 0000000000..b968a5eddc
--- /dev/null
+++ b/tests/unit/Authorization/AuthorizationTest.php
@@ -0,0 +1,382 @@
+<?php
+
+namespace Tests\Unit\Authorization;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Authorization\Input;
+
+class AuthorizationTest extends TestCase
+{
+    private Authorization $auth;
+
+    protected function setUp(): void
+    {
+        $this->auth = new Authorization();
+    }
+
+    public function testDefaultRolesContainAny(): void
+    {
+        $roles = $this->auth->getRoles();
+        $this->assertContains('any', $roles);
+        $this->assertCount(1, $roles);
+    }
+
+    public function testIsValidWithMatchingRole(): void
+    {
+        $this->auth->addRole('user:123');
+        $input = new Input(PermissionType::Read, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithNonMatchingRole(): void
+    {
+        $this->auth->addRole('user:123');
+        $input = new Input(PermissionType::Read, ['user:456']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithAnyRoleMatchesAllPermissions(): void
+    {
+        $input = new Input(PermissionType::Read, ['any']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidReturnsFalseWithEmptyPermissions(): void
+    {
+        $input = new Input(PermissionType::Read, []);
+        $this->assertFalse($this->auth->isValid($input));
+        $this->assertStringContainsString('No permissions provided', $this->auth->getDescription());
+    }
+
+    public function testIsValidReturnsFalseWithInvalidInput(): void
+    {
+        $this->assertFalse($this->auth->isValid('not-an-input'));
+        $this->assertEquals('Invalid input provided', $this->auth->getDescription());
+    }
+
+    public function testAddRole(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->assertTrue($this->auth->hasRole('user:123'));
+        $this->assertContains('user:123', $this->auth->getRoles());
+    }
+
+    public function testRemoveRole(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->assertTrue($this->auth->hasRole('user:123'));
+
+        $this->auth->removeRole('user:123');
+        $this->assertFalse($this->auth->hasRole('user:123'));
+    }
+
+    public function testGetRolesReturnsAllRoles(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->auth->addRole('team:456');
+        $this->auth->addRole('users');
+
+        $roles = $this->auth->getRoles();
+        $this->assertContains('any', $roles);
+        $this->assertContains('user:123', $roles);
+        $this->assertContains('team:456', $roles);
+        $this->assertContains('users', $roles);
+        $this->assertCount(4, $roles);
+    }
+
+    public function testSkipBypassesAuthorization(): void
+    {
+        $this->auth->cleanRoles();
+
+        $input = new Input(PermissionType::Read, ['user:999']);
+        $this->assertFalse($this->auth->isValid($input));
+
+        $result = $this->auth->skip(function () use ($input) {
+            return $this->auth->isValid($input);
+        });
+
+        $this->assertTrue($result);
+    }
+
+    public function testSkipRestoresStatusAfterCallback(): void
+    {
+        $this->assertTrue($this->auth->getStatus());
+
+        $this->auth->skip(function () {
+            $this->assertFalse($this->auth->getStatus());
+        });
+
+        $this->assertTrue($this->auth->getStatus());
+    }
+
+    public function testSkipRestoresStatusOnException(): void
+    {
+        $this->assertTrue($this->auth->getStatus());
+
+        try {
+            $this->auth->skip(function () {
+                throw new \RuntimeException('test');
+            });
+        } catch (\RuntimeException) {
+        }
+
+        $this->assertTrue($this->auth->getStatus());
+    }
+
+    public function testIsValidWithMultipleRoles(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->auth->addRole('team:456');
+
+        $input = new Input(PermissionType::Read, ['team:456']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithMultiplePermissionsMatchesFirst(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Read, ['user:123', 'team:456']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithMultiplePermissionsMatchesLast(): void
+    {
+        $this->auth->addRole('team:456');
+
+        $input = new Input(PermissionType::Read, ['user:123', 'team:456']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithGuestsRole(): void
+    {
+        $this->auth->addRole('guests');
+
+        $input = new Input(PermissionType::Read, ['guests']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithUsersRole(): void
+    {
+        $this->auth->addRole('users');
+
+        $input = new Input(PermissionType::Read, ['users']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testIsValidWithDimensionalRole(): void
+    {
+        $this->auth->addRole('user:123/admin');
+
+        $input = new Input(PermissionType::Read, ['user:123/admin']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testDimensionalRoleDoesNotMatchWithoutDimension(): void
+    {
+        $this->auth->addRole('user:123/admin');
+
+        $input = new Input(PermissionType::Read, ['user:123']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+
+    public function testNonDimensionalRoleDoesNotMatchWithDimension(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Read, ['user:123/admin']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+
+    public function testGetDescriptionOnFailure(): void
+    {
+        $this->auth->cleanRoles();
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Read, ['team:456']);
+        $this->assertFalse($this->auth->isValid($input));
+
+        $description = $this->auth->getDescription();
+        $this->assertStringContainsString('Missing "read" permission', $description);
+        $this->assertStringContainsString('team:456', $description);
+    }
+
+    public function testGetDescriptionOnEmptyPermissions(): void
+    {
+        $input = new Input(PermissionType::Write, []);
+        $this->assertFalse($this->auth->isValid($input));
+        $this->assertStringContainsString("No permissions provided for action 'write'", $this->auth->getDescription());
+    }
+
+    public function testCleanRolesRemovesAll(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->auth->addRole('team:456');
+        $this->assertCount(3, $this->auth->getRoles());
+
+        $this->auth->cleanRoles();
+        $this->assertCount(0, $this->auth->getRoles());
+        $this->assertFalse($this->auth->hasRole('any'));
+    }
+
+    public function testDisableAndEnable(): void
+    {
+        $this->assertTrue($this->auth->getStatus());
+
+        $this->auth->disable();
+        $this->assertFalse($this->auth->getStatus());
+
+        $this->auth->enable();
+        $this->assertTrue($this->auth->getStatus());
+    }
+
+    public function testDisabledAuthorizationBypassesAllChecks(): void
+    {
+        $this->auth->disable();
+        $this->auth->cleanRoles();
+
+        $input = new Input(PermissionType::Read, ['user:999']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testSetDefaultStatus(): void
+    {
+        $this->auth->setDefaultStatus(false);
+        $this->assertFalse($this->auth->getStatus());
+
+        $this->auth->reset();
+        $this->assertFalse($this->auth->getStatus());
+    }
+
+    public function testResetRestoresDefaultStatus(): void
+    {
+        $this->auth->setDefaultStatus(true);
+        $this->auth->disable();
+        $this->assertFalse($this->auth->getStatus());
+
+        $this->auth->reset();
+        $this->assertTrue($this->auth->getStatus());
+    }
+
+    public function testPermissionTypeMatchingRead(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Read, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testPermissionTypeMatchingCreate(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Create, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testPermissionTypeMatchingUpdate(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Update, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testPermissionTypeMatchingDelete(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Delete, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testPermissionTypeMatchingWrite(): void
+    {
+        $this->auth->addRole('user:123');
+
+        $input = new Input(PermissionType::Write, ['user:123']);
+        $this->assertTrue($this->auth->isValid($input));
+    }
+
+    public function testHasRole(): void
+    {
+        $this->assertTrue($this->auth->hasRole('any'));
+        $this->assertFalse($this->auth->hasRole('user:123'));
+
+        $this->auth->addRole('user:123');
+        $this->assertTrue($this->auth->hasRole('user:123'));
+    }
+
+    public function testIsArray(): void
+    {
+        $this->assertFalse($this->auth->isArray());
+    }
+
+    public function testGetType(): void
+    {
+        $this->assertEquals('array', $this->auth->getType());
+    }
+
+    public function testInputSettersAndGetters(): void
+    {
+        $input = new Input(PermissionType::Read, ['user:123']);
+        $this->assertEquals('read', $input->getAction());
+        $this->assertEquals(['user:123'], $input->getPermissions());
+
+        $input->setAction(PermissionType::Write);
+        $this->assertEquals('write', $input->getAction());
+
+        $input->setPermissions(['team:456']);
+        $this->assertEquals(['team:456'], $input->getPermissions());
+    }
+
+    public function testIsValidWithTeamDimensionRole(): void
+    {
+        $this->auth->addRole('team:abc/owner');
+
+        $input = new Input(PermissionType::Read, ['team:abc/owner']);
+        $this->assertTrue($this->auth->isValid($input));
+
+        $input = new Input(PermissionType::Read, ['team:abc/member']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+
+    public function testAddingDuplicateRoleDoesNotDuplicate(): void
+    {
+        $this->auth->addRole('user:123');
+        $this->auth->addRole('user:123');
+
+        $roles = array_filter($this->auth->getRoles(), fn ($r) => $r === 'user:123');
+        $this->assertCount(1, $roles);
+    }
+
+    public function testRemovingNonExistentRoleDoesNotThrow(): void
+    {
+        $this->auth->removeRole('nonexistent');
+        $this->assertFalse($this->auth->hasRole('nonexistent'));
+    }
+
+    public function testLabelRole(): void
+    {
+        $this->auth->addRole('label:vip');
+
+        $input = new Input(PermissionType::Read, ['label:vip']);
+        $this->assertTrue($this->auth->isValid($input));
+
+        $input = new Input(PermissionType::Read, ['label:premium']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+
+    public function testMemberRole(): void
+    {
+        $this->auth->addRole('member:abc123');
+
+        $input = new Input(PermissionType::Read, ['member:abc123']);
+        $this->assertTrue($this->auth->isValid($input));
+
+        $input = new Input(PermissionType::Read, ['member:def456']);
+        $this->assertFalse($this->auth->isValid($input));
+    }
+}
diff --git a/tests/unit/Authorization/PermissionCheckTest.php b/tests/unit/Authorization/PermissionCheckTest.php
new file mode 100644
index 0000000000..a36b237635
--- /dev/null
+++ b/tests/unit/Authorization/PermissionCheckTest.php
@@ -0,0 +1,896 @@
+<?php
+
+namespace Tests\Unit\Authorization;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None as NoneAdapter;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Validator\Authorization;
+
+class PermissionCheckTest extends TestCase
+{
+    private Database $database;
+
+    private Adapter&Stub $adapter;
+
+    private Authorization $authorization;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('1970-01-01 00:00:00'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('2999-12-31 23:59:59'));
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return match ($cap) {
+                Capability::DefinedAttributes => true,
+                default => false,
+            };
+        });
+        $this->adapter->method('withTransaction')->willReturnCallback(
+            fn (callable $callback) => $callback()
+        );
+        $this->adapter->method('getSequences')->willReturnCallback(
+            fn (string $collection, array $documents) => $documents
+        );
+
+        $cache = new Cache(new NoneAdapter());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->disableValidation();
+        $this->database->disableFilters();
+
+        $this->authorization = $this->database->getAuthorization();
+    }
+
+    /**
+     * @param  array<string>  $permissions
+     */
+    private function buildCollectionDoc(
+        string $id,
+        array $permissions = [],
+        bool $documentSecurity = false
+    ): Document {
+        return new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $id,
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => $documentSecurity,
+        ]);
+    }
+
+    private function configureAdapterForCollection(Document $collection): void
+    {
+        $collectionId = $collection->getId();
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testCreateDocumentThrowsWithoutCreatePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::user('owner')),
+            Permission::read(Role::any()),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+        ]));
+    }
+
+    public function testCreateDocumentSucceedsWithCreatePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::user('owner')),
+            Permission::read(Role::any()),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+        ]));
+
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testCreateDocumentSucceedsWithCollectionCreatePermissionForAny(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('any');
+
+        $result = $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc2',
+            '$permissions' => [],
+        ]));
+
+        $this->assertEquals('doc2', $result->getId());
+    }
+
+    public function testUpdateDocumentThrowsWithoutUpdatePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$version' => 1,
+            'title' => 'old',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->updateDocument('test_col', 'doc1', new Document([
+            '$id' => 'doc1',
+            'title' => 'new',
+        ]));
+    }
+
+    public function testUpdateDocumentSucceedsWithUpdatePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$version' => 1,
+            'title' => 'old',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('updateDocument')->willReturnCallback(
+            fn (Document $col, string $id, Document $doc, bool $skipPerms) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->updateDocument('test_col', 'doc1', new Document([
+            '$id' => 'doc1',
+            'title' => 'new',
+        ]));
+
+        $this->assertNotEmpty($result->getId());
+    }
+
+    public function testDeleteDocumentThrowsWithoutDeletePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->deleteDocument('test_col', 'doc1');
+    }
+
+    public function testDeleteDocumentSucceedsWithDeletePermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('deleteDocument')->willReturn(true);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->deleteDocument('test_col', 'doc1');
+        $this->assertTrue($result);
+    }
+
+    public function testGetDocumentReturnsEmptyWithoutReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $result = $this->database->getDocument('test_col', 'doc1');
+        $this->assertTrue($result->isEmpty());
+    }
+
+    public function testGetDocumentSucceedsWithReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->getDocument('test_col', 'doc1');
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testFindThrowsWithoutReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->find('test_col');
+    }
+
+    public function testFindSucceedsWithReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('find')->willReturn([
+            new Document([
+                '$id' => 'doc1',
+                '$permissions' => [],
+            ]),
+        ]);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $results = $this->database->find('test_col');
+        $this->assertCount(1, $results);
+    }
+
+    public function testDocumentLevelSecurityAllowsReadWithDocPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+        ], documentSecurity: true);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [
+                Permission::read(Role::user('reader')),
+            ],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:reader');
+
+        $result = $this->database->getDocument('test_col', 'doc1');
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testDocumentLevelSecurityDeniesReadWithoutDocPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+        ], documentSecurity: true);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [
+                Permission::read(Role::user('reader')),
+            ],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:stranger');
+
+        $result = $this->database->getDocument('test_col', 'doc1');
+        $this->assertTrue($result->isEmpty());
+    }
+
+    public function testAggregatedWritePermissionGrantsCreate(): void
+    {
+        $permissions = Permission::aggregate([Permission::write(Role::user('writer'))]);
+        $permissions[] = Permission::read(Role::any());
+
+        $collection = $this->buildCollectionDoc('test_col', $permissions);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:writer');
+
+        $result = $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+        ]));
+
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testAggregatedWritePermissionGrantsUpdate(): void
+    {
+        $permissions = Permission::aggregate([Permission::write(Role::user('writer'))]);
+        $permissions[] = Permission::read(Role::any());
+
+        $collection = $this->buildCollectionDoc('test_col', $permissions);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$version' => 1,
+            'title' => 'old',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('updateDocument')->willReturnCallback(
+            fn (Document $col, string $id, Document $doc, bool $skipPerms) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:writer');
+
+        $result = $this->database->updateDocument('test_col', 'doc1', new Document([
+            '$id' => 'doc1',
+            'title' => 'new',
+        ]));
+
+        $this->assertNotEmpty($result->getId());
+    }
+
+    public function testAggregatedWritePermissionGrantsDelete(): void
+    {
+        $permissions = Permission::aggregate([Permission::write(Role::user('writer'))]);
+        $permissions[] = Permission::read(Role::any());
+
+        $collection = $this->buildCollectionDoc('test_col', $permissions);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('deleteDocument')->willReturn(true);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:writer');
+
+        $result = $this->database->deleteDocument('test_col', 'doc1');
+        $this->assertTrue($result);
+    }
+
+    public function testSkipAuthorizationBypassesAllChecks(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::user('nobody')),
+            Permission::read(Role::user('nobody')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+
+        $result = $this->authorization->skip(function () {
+            return $this->database->createDocument('test_col', new Document([
+                '$id' => 'doc1',
+                '$permissions' => [],
+            ]));
+        });
+
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testCountThrowsWithoutReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->count('test_col');
+    }
+
+    public function testCountSucceedsWithReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('count')->willReturn(5);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->count('test_col');
+        $this->assertEquals(5, $result);
+    }
+
+    public function testSumThrowsWithoutReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:other');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->sum('test_col', 'amount');
+    }
+
+    public function testSumSucceedsWithReadPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::user('owner')),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('sum')->willReturn(42.5);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:owner');
+
+        $result = $this->database->sum('test_col', 'amount');
+        $this->assertEquals(42.5, $result);
+    }
+
+    public function testDocumentSecurityAllowsUpdateWithDocPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::any()),
+        ], documentSecurity: true);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [
+                Permission::update(Role::user('editor')),
+                Permission::read(Role::any()),
+            ],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$version' => 1,
+            'title' => 'old',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('updateDocument')->willReturnCallback(
+            fn (Document $col, string $id, Document $doc, bool $skipPerms) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:editor');
+
+        $result = $this->database->updateDocument('test_col', 'doc1', new Document([
+            '$id' => 'doc1',
+            'title' => 'new',
+        ]));
+
+        $this->assertNotEmpty($result->getId());
+    }
+
+    public function testDocumentSecurityAllowsDeleteWithDocPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::read(Role::any()),
+        ], documentSecurity: true);
+
+        $existingDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'test_col',
+            '$permissions' => [
+                Permission::delete(Role::user('deleter')),
+            ],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+
+        $collectionId = $collection->getId();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id, array $queries = [], bool $forUpdate = false) use ($collection, $collectionId, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $id === $collectionId) {
+                    return $collection;
+                }
+                if ($id === 'doc1') {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('deleteDocument')->willReturn(true);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:deleter');
+
+        $result = $this->database->deleteDocument('test_col', 'doc1');
+        $this->assertTrue($result);
+    }
+
+    public function testFindWithDocumentSecurityAndNoCollectionPermission(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+        ], documentSecurity: true);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('find')->willReturn([
+            new Document([
+                '$id' => 'doc1',
+                '$permissions' => [Permission::read(Role::user('viewer'))],
+            ]),
+        ]);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:viewer');
+
+        $results = $this->database->find('test_col');
+        $this->assertCount(1, $results);
+    }
+
+    public function testFindWithDocumentSecurityThrowsWithNoPermissionAtAll(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [], documentSecurity: false);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:nobody');
+
+        $this->expectException(AuthorizationException::class);
+
+        $this->database->find('test_col');
+    }
+
+    public function testCountWithDocumentSecurityDoesNotThrow(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::any()),
+        ], documentSecurity: true);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('count')->willReturn(3);
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('user:viewer');
+
+        $result = $this->database->count('test_col');
+        $this->assertEquals(3, $result);
+    }
+
+    public function testCreateDocumentWithUsersRole(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::users()),
+            Permission::read(Role::any()),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('users');
+
+        $result = $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+        ]));
+
+        $this->assertEquals('doc1', $result->getId());
+    }
+
+    public function testCreateDocumentWithTeamRole(): void
+    {
+        $collection = $this->buildCollectionDoc('test_col', [
+            Permission::create(Role::team('abc', 'admin')),
+            Permission::read(Role::any()),
+        ]);
+
+        $this->configureAdapterForCollection($collection);
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->authorization->cleanRoles();
+        $this->authorization->addRole('team:abc/admin');
+
+        $result = $this->database->createDocument('test_col', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+        ]));
+
+        $this->assertEquals('doc1', $result->getId());
+    }
+}
diff --git a/tests/unit/BigIntegerTest.php b/tests/unit/BigIntegerTest.php
new file mode 100644
index 0000000000..c25c68633d
--- /dev/null
+++ b/tests/unit/BigIntegerTest.php
@@ -0,0 +1,242 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Adapter\Mongo;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Adapter\Redis as RedisAdapter;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\Type as TypeException;
+use Utopia\Database\Operator;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\BigInt;
+use Utopia\Query\Schema\ColumnType;
+
+final class BigIntegerTest extends TestCase
+{
+    public function testUnsignedBoundsAndArithmeticStayExact(): void
+    {
+        $bounds = Attribute::getNumericBounds(ColumnType::BigInteger, false);
+
+        $this->assertNotNull($bounds);
+        $this->assertSame('18446744073709551615', $bounds['max']);
+        $this->assertSame('9223372036854775808', BigInt::add(PHP_INT_MAX, 1));
+        $this->assertSame(PHP_INT_MAX, BigInt::subtract('9223372036854775808', 1));
+        $this->assertSame('18446744073709551615', BigInt::add('18446744073709551614', 1));
+        $this->assertSame('18446744073709551616', BigInt::add(BigInt::UNSIGNED_MAX, 1));
+        $this->assertSame('18446744073709551614', BigInt::subtract(BigInt::UNSIGNED_MAX, 1));
+        $this->assertSame('18446744073709551614', BigInt::multiply('9223372036854775807', 2));
+        $this->assertSame(1, BigInt::modulo(BigInt::UNSIGNED_MAX, 2));
+    }
+
+    public function testSqlColumnTypesMapBigIntegerAndLegacyMetadata(): void
+    {
+        $mariaDB = new MariaDB(new \stdClass());
+        $postgres = new Postgres(new \stdClass());
+
+        $this->assertSame('BIGINT', $mariaDB->getColumnType(ColumnType::BigInteger->value, 0));
+        $this->assertSame('BIGINT', $mariaDB->getColumnType('bigint', 9999));
+        $this->assertSame('BIGINT UNSIGNED', $mariaDB->getColumnType(ColumnType::BigInteger->value, 0, false));
+        $this->assertSame('BIGINT', $mariaDB->getColumnType(ColumnType::BigSerial->value, 0));
+        $this->assertSame('BIGINT', $postgres->getColumnType(ColumnType::BigInteger->value, 0));
+        $this->assertSame('BIGINT', $postgres->getColumnType('bigint', 9999));
+        $this->assertSame('BIGSERIAL', $postgres->getColumnType(ColumnType::BigSerial->value, 0));
+    }
+
+    public function testCastingNormalizesLegacyBigIntegerWithoutPrecisionLoss(): void
+    {
+        /** @var Adapter&Stub $adapter */
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('supports')->willReturnCallback(
+            static fn (Capability $capability): bool => $capability === Capability::Casting
+        );
+        $database = new Database($adapter, new Cache(new None()));
+        $collection = new Document([
+            'attributes' => [
+                [
+                    '$id' => 'signed',
+                    'type' => 'bigint',
+                    'array' => false,
+                    'signed' => true,
+                ],
+                [
+                    '$id' => 'unsigned',
+                    'type' => ColumnType::BigInteger->value,
+                    'array' => false,
+                    'signed' => false,
+                ],
+            ],
+        ]);
+        $document = new Document([
+            'signed' => '9223372036854775807',
+            'unsigned' => '18446744073709551615',
+        ]);
+
+        $result = $database->casting($collection, $document);
+
+        $this->assertSame(PHP_INT_MAX, $result->getAttribute('signed'));
+        $this->assertSame('18446744073709551615', $result->getAttribute('unsigned'));
+    }
+
+    public function testSQLiteCreatesAndReadsBigIntegerColumn(): void
+    {
+        $adapter = new SQLite(new \PDO('sqlite::memory:'));
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+        $collection = new Document([
+            '$id' => 'bigints',
+            'attributes' => [new Document([
+                '$id' => 'value',
+                'type' => ColumnType::BigInteger->value,
+                'array' => false,
+            ])],
+        ]);
+
+        $this->assertTrue($adapter->createCollection('bigints', [
+            Attribute::bigInteger(key: 'value'),
+        ]));
+        $adapter->createDocument($collection, new Document([
+            '$id' => 'maximum',
+            '$permissions' => [],
+            'value' => PHP_INT_MAX,
+        ]));
+
+        $stored = $adapter->getDocument($collection, 'maximum')->getAttribute('value');
+        $this->assertTrue(\is_int($stored) || \is_string($stored));
+        $this->assertSame((string) PHP_INT_MAX, (string) $stored);
+    }
+
+    public function testMemoryOperatorPreservesUnsignedIntegerStrings(): void
+    {
+        $adapter = new class () extends Memory {
+            public function apply(mixed $current, Operator $operator): mixed
+            {
+                return $this->applyOperator($current, $operator);
+            }
+        };
+
+        $this->assertSame(
+            '9223372036854775808',
+            $adapter->apply(PHP_INT_MAX, Operator::increment(1)),
+        );
+        $this->assertSame(
+            '18446744073709551615',
+            $adapter->apply('18446744073709551614', Operator::increment(1)),
+        );
+        $this->assertSame(
+            PHP_INT_MAX,
+            $adapter->apply('9223372036854775808', Operator::decrement(1)),
+        );
+    }
+
+    public function testMemoryAndRedisOperatorsLeaveValuesUnchangedWhenBoundsAreCrossed(): void
+    {
+        $memory = new class () extends Memory {
+            public function apply(mixed $current, Operator $operator): mixed
+            {
+                return $this->applyOperator($current, $operator);
+            }
+        };
+        $redis = new class (self::createStub(\Redis::class)) extends RedisAdapter {
+            public function apply(mixed $current, Operator $operator): mixed
+            {
+                return $this->applyOperator($current, $operator);
+            }
+        };
+
+        $cases = [
+            [10, Operator::increment(100, 50), 10],
+            [5.0, Operator::decrement(10, 0), 5.0],
+            [10, Operator::multiply(10, 75), 10],
+            [100.0, Operator::divide(-4, -10), 100.0],
+            [20.0, Operator::divide(-2, -50), -10.0],
+            [80.0, Operator::multiply(0.5, 50), 40.0],
+            [52.0, Operator::increment(-5, 50), 47.0],
+            [10, Operator::increment(5, 15), 15],
+            [10, Operator::decrement(5, 5), 5],
+            [-10.0, Operator::multiply(-2, 50), 20.0],
+            [5.0, Operator::power(3, 100), 5.0],
+            [100.0, Operator::power(0.5, 50), 10.0],
+            [-4.0, Operator::power(2, 20), 16.0],
+            [-2.0, Operator::power(3, 100), -8.0],
+            [0.0, Operator::power(-1, 100), 0.0],
+            [-4.0, Operator::power(0.5, 100), -4.0],
+            [PHP_INT_MAX, Operator::increment(2, PHP_INT_MAX), PHP_INT_MAX],
+            [PHP_INT_MAX, Operator::increment(1, BigInt::UNSIGNED_MAX), '9223372036854775808'],
+        ];
+
+        foreach ([$memory, $redis] as $adapter) {
+            foreach ($cases as [$current, $operator, $expected]) {
+                $this->assertSame($expected, $adapter->apply($current, $operator));
+            }
+        }
+    }
+
+    public function testMemoryAndRedisRejectUnboundedInvalidPowers(): void
+    {
+        $adapters = [
+            new class () extends Memory {
+                public function apply(mixed $current, Operator $operator): mixed
+                {
+                    return $this->applyOperator($current, $operator);
+                }
+            },
+            new class (self::createStub(\Redis::class)) extends RedisAdapter {
+                public function apply(mixed $current, Operator $operator): mixed
+                {
+                    return $this->applyOperator($current, $operator);
+                }
+            },
+        ];
+
+        foreach ($adapters as $adapter) {
+            try {
+                $adapter->apply(0.0, Operator::power(-1));
+                $this->fail('Expected invalid power to throw');
+            } catch (LimitException $exception) {
+                $this->assertSame('Value out of range', $exception->getMessage());
+            }
+        }
+    }
+
+    public function testSqlBuilderPreservesUnsignedIntegerBindings(): void
+    {
+        $adapter = new class (new \stdClass()) extends MariaDB {
+            /**
+             * @return array{expression: string, bindings: list<mixed>}
+             */
+            public function expression(Operator $operator): array
+            {
+                return $this->getOperatorBuilderExpression('value', $operator);
+            }
+        };
+
+        $result = $adapter->expression(Operator::increment(1, BigInt::UNSIGNED_MAX));
+
+        $this->assertStringContainsString('CASE', $result['expression']);
+        $this->assertSame([BigInt::UNSIGNED_MAX, 1, 1], $result['bindings']);
+    }
+
+    public function testMongoRejectsUnsignedArithmeticBeforeBsonCoercion(): void
+    {
+        $adapter = (new \ReflectionClass(Mongo::class))->newInstanceWithoutConstructor();
+
+        $this->expectException(TypeException::class);
+        $this->expectExceptionMessage('outside the signed 64-bit integer range');
+        $adapter->increaseDocumentAttribute('collection', 'document', 'value', BigInt::UNSIGNED_MAX, '2026-01-01T00:00:00.000+00:00');
+    }
+}
diff --git a/tests/unit/CLITasksTest.php b/tests/unit/CLITasksTest.php
new file mode 100644
index 0000000000..274c5faa85
--- /dev/null
+++ b/tests/unit/CLITasksTest.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+
+final class CLITasksTest extends TestCase
+{
+    public function testOperatorSetupUsesDatabaseAuthorization(): void
+    {
+        $source = \file_get_contents(__DIR__.'/../../bin/tasks/operators.php');
+        $this->assertIsString($source);
+        $this->assertStringContainsString(
+            '$database->getAuthorization()->addRole(Role::any()->toString());',
+            $source,
+        );
+        $this->assertStringNotContainsString('$authorization->', $source);
+    }
+}
diff --git a/tests/unit/Cache/DatabaseQueryCacheTest.php b/tests/unit/Cache/DatabaseQueryCacheTest.php
new file mode 100644
index 0000000000..73569c7af2
--- /dev/null
+++ b/tests/unit/Cache/DatabaseQueryCacheTest.php
@@ -0,0 +1,1104 @@
+<?php
+
+namespace Tests\Unit\Cache;
+
+use Closure;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter as CacheAdapter;
+use Utopia\Cache\Adapter\Memory as MemoryCache;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Cache\Feature\Leasable;
+use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Adapter\Pool;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Cache\QueryCache;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Conflict;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Pools\Pool as UtopiaPool;
+use Utopia\Query\CursorDirection;
+
+final class DatabaseQueryCacheTest extends TestCase
+{
+    public function testQueryCacheSeparatesCompleteExecutionShapes(): void
+    {
+        [$database] = $this->createDatabase();
+        $this->createUsers($database);
+
+        $ascending = $database->find('users', [
+            Query::orderAsc('$id'),
+            Query::limit(1),
+        ]);
+        $two = $database->find('users', [
+            Query::orderAsc('$id'),
+            Query::limit(2),
+        ]);
+        $offset = $database->find('users', [
+            Query::orderAsc('$id'),
+            Query::limit(1),
+            Query::offset(1),
+        ]);
+        $descending = $database->find('users', [
+            Query::orderDesc('$id'),
+            Query::limit(1),
+        ]);
+
+        $cursorA = $database->getDocument('users', 'a');
+        $cursorB = $database->getDocument('users', 'b');
+        $afterA = $database->find('users', [
+            Query::orderAsc('$id'),
+            Query::cursorAfter($cursorA),
+            Query::limit(1),
+        ]);
+        $afterB = $database->find('users', [
+            Query::orderAsc('$id'),
+            Query::cursorAfter($cursorB),
+            Query::limit(1),
+        ]);
+
+        $this->assertSame(['a'], $this->ids($ascending));
+        $this->assertSame(['a', 'b'], $this->ids($two));
+        $this->assertSame(['b'], $this->ids($offset));
+        $this->assertSame(['c'], $this->ids($descending));
+        $this->assertSame(['b'], $this->ids($afterA));
+        $this->assertSame(['c'], $this->ids($afterB));
+    }
+
+    public function testRandomOrderAlwaysBypassesQueryCache(): void
+    {
+        $adapter = new ObservedMemory();
+        [$database] = $this->createDatabase($adapter);
+        $this->createUsers($database);
+
+        $adapter->observeFinds('users');
+        $database->find('users', [Query::orderRandom(), Query::limit(1)]);
+        $database->find('users', [Query::orderRandom(), Query::limit(1)]);
+
+        $this->assertSame(2, $adapter->getObservedFinds());
+    }
+
+    public function testSetQueryCacheInstallsOneInvalidatorAndRemovesIt(): void
+    {
+        [$database, $queryAdapter] = $this->createDatabase(queryCache: false);
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+
+        $queryCache = new QueryCache(new Cache($queryAdapter));
+        $database->setQueryCache($queryCache);
+        $database->setQueryCache($queryCache);
+
+        $queryAdapter->resetPurges();
+        $database->createDocument('users', new Document(['$id' => 'a']));
+        $this->assertSame(2, $queryAdapter->getWrites('default:qcache:users#epoch'));
+
+        $database->setQueryCache(null);
+        $queryAdapter->resetPurges();
+        $database->createDocument('users', new Document(['$id' => 'b']));
+        $this->assertSame(0, $queryAdapter->getWrites('default:qcache:users#epoch'));
+    }
+
+    public function testSchemaAndCollectionMutationsInvalidateQueries(): void
+    {
+        [$database, $queryAdapter] = $this->createDatabase();
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+
+        $queryAdapter->resetPurges();
+        $database->updateCollection('users', $this->permissions(), false);
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->createAttribute('users', Attribute::string(key: 'name'));
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->updateAttribute('users', 'name', size: 128);
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->createIndex('users', Index::key(key: 'name', attributes: ['name']));
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->renameIndex('users', 'name', 'renamed');
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->deleteIndex('users', 'renamed');
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+
+        $queryAdapter->resetPurges();
+        $database->deleteAttribute('users', 'name');
+        $this->assertGreaterThan(0, $queryAdapter->getPurges('default:qcache:users#epoch'));
+    }
+
+    public function testDeleteAndRecreateCannotReuseOldCollectionResults(): void
+    {
+        [$database] = $this->createDatabase();
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document(['$id' => 'old']));
+        $this->assertSame(['old'], $this->ids($database->find('users')));
+
+        $database->deleteCollection('users');
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document(['$id' => 'new']));
+
+        $this->assertSame(['new'], $this->ids($database->find('users')));
+    }
+
+    public function testRolledBackTransactionCannotPoisonQueryCache(): void
+    {
+        [$database] = $this->createDatabase();
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document(['$id' => 'committed']));
+        $this->assertSame(['committed'], $this->ids($database->find('users')));
+
+        try {
+            $database->withTransaction(function () use ($database): void {
+                $database->createDocument('users', new Document(['$id' => 'rolled-back']));
+                $this->assertSame(
+                    ['committed', 'rolled-back'],
+                    $this->ids($database->find('users', [Query::orderAsc('$id')])),
+                );
+
+                throw new Conflict('rollback');
+            });
+        } catch (Conflict) {
+        }
+
+        $this->assertSame(
+            ['committed'],
+            $this->ids($database->find('users', [Query::orderAsc('$id')])),
+        );
+    }
+
+    public function testMetadataReadStartedBeforePurgeCannotPublish(): void
+    {
+        $adapter = new ObservedMemory();
+        [$database] = $this->createDatabase($adapter, queryCache: false, dataAdapter: new None());
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        $database->purgeCachedCollection('users');
+
+        $adapter->observeMetadata('users', fn () => $database->purgeCachedCollection('users'));
+        $database->getCollection('users');
+        $database->getCollection('users');
+
+        $this->assertSame(2, $adapter->getObservedMetadataReads());
+    }
+
+    public function testValidatorBuildStartedBeforePurgeCannotPublish(): void
+    {
+        $adapter = new ObservedMemory();
+        [$database] = $this->createDatabase($adapter, queryCache: false);
+        $database->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'name'),
+        ], permissions: $this->permissions(), documentSecurity: false));
+        $database->getCollection('users');
+
+        $adapter->observeValidators(
+            fn () => $database->createAttribute('users', Attribute::integer(key: 'age')),
+        );
+        $database->find('users', [Query::equal('name', ['first'])]);
+        $database->find('users', [Query::equal('name', ['second'])]);
+
+        $this->assertSame(2, $adapter->getObservedValidators());
+    }
+
+    public function testMemoryCacheSeparatesRolesAndExecutionShapes(): void
+    {
+        [$database] = $this->createDatabase(queryCache: false);
+        $database->setQueryCache(new QueryCache(new Cache(new MemoryCache())));
+        $database->getAuthorization()->skip(function () use ($database): void {
+            $database->createCollection(new Collection(id: 'private', permissions: [
+                Permission::create(Role::any()),
+            ]));
+
+            foreach ([
+                ['a', 'user-1'],
+                ['b', 'user-2'],
+                ['c', 'user-1'],
+            ] as [$id, $user]) {
+                $database->createDocument('private', new Document([
+                    '$id' => $id,
+                    '$permissions' => [Permission::read(Role::user($user))],
+                ]));
+            }
+        });
+
+        $authorization = $database->getAuthorization();
+        $authorization->addRole(Role::user('user-1')->toString());
+        $this->assertSame(['a'], $this->ids($database->find('private', [
+            Query::orderAsc('$id'),
+            Query::limit(1),
+        ])));
+        $this->assertSame(['c'], $this->ids($database->find('private', [
+            Query::orderDesc('$id'),
+            Query::limit(1),
+        ])));
+        $this->assertSame(['a', 'c'], $this->ids($database->find('private', [
+            Query::orderAsc('$id'),
+            Query::limit(2),
+        ])));
+
+        $authorization->removeRole(Role::user('user-1')->toString());
+        $authorization->addRole(Role::user('user-2')->toString());
+        $this->assertSame(['b'], $this->ids($database->find('private', [
+            Query::orderAsc('$id'),
+            Query::limit(2),
+        ])));
+    }
+
+    public function testMemoryCacheSeparatesPointSelectionVariants(): void
+    {
+        [$database] = $this->createDatabase(queryCache: false, dataAdapter: new MemoryCache());
+        $database->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'name'),
+            Attribute::string(key: 'email'),
+        ], permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document([
+            '$id' => 'user',
+            'name' => 'Alice',
+            'email' => 'alice@example.com',
+        ]));
+
+        $name = $database->getDocument('users', 'user', [Query::select(['name'])]);
+        $email = $database->getDocument('users', 'user', [Query::select(['email'])]);
+
+        $this->assertSame('Alice', $name->getAttribute('name'));
+        $this->assertNull($name->getAttribute('email'));
+        $this->assertSame('alice@example.com', $email->getAttribute('email'));
+        $this->assertNull($email->getAttribute('name'));
+    }
+
+    public function testPermissionRevocationIsFreshAcrossDatabaseInstances(): void
+    {
+        $adapter = new DatabaseMemory();
+        $authorization = new Authorization();
+        $authorization->cleanRoles();
+        $authorization->addRole(Role::user('user-1')->toString());
+        $writer = new Database($adapter, new Cache(new None()));
+        $reader = new Database($adapter, new Cache(new None()));
+
+        foreach ([$writer, $reader] as $database) {
+            $database
+                ->setAuthorization($authorization)
+                ->setDatabase('cache-tests')
+                ->setNamespace('shared_metadata');
+        }
+
+        $writer->create();
+        $writer->createCollection(new Collection(id: 'users', permissions: [
+            Permission::read(Role::user('user-1')),
+            Permission::create(Role::user('user-1')),
+            Permission::update(Role::user('user-1')),
+        ]));
+        $reader->getCollection('users');
+
+        $writer->updateCollection('users', [
+            Permission::create(Role::user('user-1')),
+            Permission::update(Role::user('user-1')),
+        ], false);
+
+        $this->expectException(AuthorizationException::class);
+        $reader->find('users');
+    }
+
+    public function testSilentPermissionRevocationStillInvalidatesQueryCache(): void
+    {
+        [$database] = $this->createDatabase(queryCache: false);
+        $database->setQueryCache(new QueryCache(new Cache(new MemoryCache())));
+        $database->getAuthorization()->skip(function () use ($database): void {
+            $database->createCollection(new Collection(id: 'private', permissions: [
+                Permission::create(Role::any()),
+            ]));
+            $database->createDocument('private', new Document([
+                '$id' => 'secret',
+                '$permissions' => [
+                    Permission::read(Role::user('user-1')),
+                    Permission::update(Role::user('user-1')),
+                ],
+            ]));
+        });
+
+        $database->getAuthorization()->addRole(Role::user('user-1')->toString());
+        $this->assertSame(['secret'], $this->ids($database->find('private')));
+
+        $database->getAuthorization()->skip(fn () => $database->silent(
+            fn () => $database->updateDocument('private', 'secret', new Document([
+                '$permissions' => [Permission::read(Role::user('user-2'))],
+            ])),
+        ));
+
+        $this->assertSame([], $database->find('private'));
+    }
+
+    public function testJoinQueriesAlwaysBypassCacheAfterRelatedMutation(): void
+    {
+        $adapter = new JoinMemory();
+        [$database] = $this->createDatabase($adapter);
+        $database->createCollection(new Collection(id: 'parents', permissions: $this->permissions(), documentSecurity: false));
+        $database->createCollection(new Collection(id: 'children', permissions: $this->permissions(), documentSecurity: false));
+
+        $queries = [Query::join('children', '$id', '$id')];
+        $database->find('parents', $queries);
+        $database->createDocument('children', new Document(['$id' => 'child']));
+        $database->find('parents', $queries);
+
+        $this->assertSame(2, $adapter->getJoinFinds());
+    }
+
+    public function testMandatoryInvalidationFailureEscapesSilentScope(): void
+    {
+        $cache = new FailingMemory();
+        [$database] = $this->createDatabase(queryCache: false);
+        $database->setQueryCache(new QueryCache(new Cache($cache)));
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        $database->find('users');
+        $cache->seedEpoch('users');
+        $cache->failPurges();
+
+        $this->expectException(\RuntimeException::class);
+        $database->silent(fn () => $database->createDocument('users', new Document(['$id' => 'user'])));
+    }
+
+    public function testCreateRollsBackWhenMandatoryInvalidationFails(): void
+    {
+        $this->assertMutationRollsBackOnInvalidationFailure(
+            static fn (Database $database) => $database->createDocument('users', new Document([
+                '$id' => 'created',
+                'name' => 'created',
+            ])),
+        );
+    }
+
+    public function testBatchCreateRollsBackWhenMandatoryInvalidationFails(): void
+    {
+        $this->assertMutationRollsBackOnInvalidationFailure(
+            static fn (Database $database) => $database->createDocuments('users', [
+                new Document(['$id' => 'first', 'name' => 'first']),
+                new Document(['$id' => 'second', 'name' => 'second']),
+            ]),
+        );
+    }
+
+    public function testUpsertRollsBackWhenMandatoryInvalidationFails(): void
+    {
+        $this->assertMutationRollsBackOnInvalidationFailure(
+            static fn (Database $database) => $database->upsertDocument('users', new Document([
+                '$id' => 'existing',
+                'name' => 'updated',
+            ])),
+            sqlite: true,
+        );
+    }
+
+    public function testUpdateRollsBackWhenMandatoryInvalidationFails(): void
+    {
+        $this->assertMutationRollsBackOnInvalidationFailure(
+            static fn (Database $database) => $database->updateDocument(
+                'users',
+                'existing',
+                new Document(['name' => 'updated']),
+            ),
+        );
+    }
+
+    public function testDeleteRollsBackWhenMandatoryInvalidationFails(): void
+    {
+        $this->assertMutationRollsBackOnInvalidationFailure(
+            static fn (Database $database) => $database->deleteDocument('users', 'existing'),
+        );
+    }
+
+    public function testSharedBlockedEpochPreventsPreCommitStaleFill(): void
+    {
+        [$writer, $reader, $writerAdapter, $readerAdapter, $cache, $path] = $this->createSharedSQLiteDatabases();
+
+        try {
+            $this->assertSame(
+                ['existing' => 'original'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $readerAdapter->observeFinds('users');
+
+            $duringCommit = [];
+            $writerAdapter->pauseNextCommit(function () use ($reader, $cache, &$duringCommit): void {
+                $epoch = $cache->load('default:qcache:users#epoch', 3600);
+                $this->assertIsString($epoch);
+                $this->assertStringStartsWith('blocked:', $epoch);
+                $duringCommit = $this->names($reader->find('users', [Query::orderAsc('$id')]));
+            });
+
+            $writer->updateDocument('users', 'existing', new Document(['name' => 'updated']));
+
+            $this->assertSame(['existing' => 'original'], $duringCommit);
+            $this->assertSame(
+                ['existing' => 'updated'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $this->assertSame(2, $readerAdapter->getObservedFinds());
+            $this->assertSame(
+                ['existing' => 'updated'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $this->assertSame(2, $readerAdapter->getObservedFinds());
+        } finally {
+            $this->removeSQLiteFiles($path);
+        }
+    }
+
+    public function testActivationFailureAfterCommitLeavesSharedEpochBlocked(): void
+    {
+        [$writer, $reader, , $readerAdapter, $cache, $path] = $this->createSharedSQLiteDatabases();
+
+        try {
+            $this->assertSame(
+                ['existing' => 'original'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $cache->failActivations();
+
+            try {
+                $writer->updateDocument('users', 'existing', new Document(['name' => 'updated']));
+                $this->fail('Post-commit query-cache activation failure was not propagated');
+            } catch (\RuntimeException $exception) {
+                $this->assertStringContainsString('activate query cache', $exception->getMessage());
+            }
+
+            $epoch = $cache->load('default:qcache:users#epoch', 3600);
+            $this->assertIsString($epoch);
+            $this->assertStringStartsWith('blocked:', $epoch);
+
+            $readerAdapter->observeFinds('users');
+            $this->assertSame(
+                ['existing' => 'updated'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $this->assertSame(
+                ['existing' => 'updated'],
+                $this->names($reader->find('users', [Query::orderAsc('$id')])),
+            );
+            $this->assertSame(2, $readerAdapter->getObservedFinds());
+        } finally {
+            $this->removeSQLiteFiles($path);
+        }
+    }
+
+    public function testPooledRollbackCannotPoisonPointOrQueryCaches(): void
+    {
+        $child = new DatabaseMemory();
+        $connections = self::createStub(UtopiaPool::class);
+        $connections->method('use')->willReturnCallback(
+            static fn (callable $callback): mixed => $callback($child),
+        );
+        $database = new Database(new Pool($connections), new Cache(new LeasableHashCache()));
+        $database
+            ->setDatabase('cache-tests')
+            ->setNamespace('pooled_'.\uniqid())
+            ->setQueryCache(new QueryCache(new Cache(new MemoryCache())));
+        $database->create();
+        $database->getAuthorization()->addRole(Role::any()->toString());
+        $database->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'name'),
+        ], permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document([
+            '$id' => 'user',
+            'name' => 'committed',
+        ]));
+        $this->assertSame('committed', $database->getDocument('users', 'user')->getAttribute('name'));
+        $this->assertSame('committed', $database->find('users')[0]->getAttribute('name'));
+
+        try {
+            $database->withTransaction(function () use ($database): void {
+                $database->updateDocument('users', 'user', new Document(['name' => 'rolled-back']));
+                $this->assertTrue($database->getAdapter()->inTransaction());
+                $this->assertSame('rolled-back', $database->getDocument('users', 'user')->getAttribute('name'));
+                $this->assertSame('rolled-back', $database->find('users')[0]->getAttribute('name'));
+
+                throw new Conflict('rollback');
+            });
+        } catch (Conflict) {
+        }
+
+        $this->assertSame('committed', $database->getDocument('users', 'user')->getAttribute('name'));
+        $this->assertSame('committed', $database->find('users')[0]->getAttribute('name'));
+    }
+
+    /**
+     * @return array{Database, LeasableHashCache}
+     */
+    private function createDatabase(
+        ?DatabaseMemory $adapter = null,
+        bool $queryCache = true,
+        ?CacheAdapter $dataAdapter = null,
+    ): array {
+        $dataAdapter ??= new LeasableHashCache();
+        $queryAdapter = new LeasableHashCache();
+        $database = new Database($adapter ?? new DatabaseMemory(), new Cache($dataAdapter));
+        $database
+            ->setDatabase('cache-tests')
+            ->setNamespace('cache_'.\uniqid());
+        $database->create();
+        $database->getAuthorization()->addRole(Role::any()->toString());
+
+        if ($queryCache) {
+            $database->setQueryCache(new QueryCache(new Cache($queryAdapter)));
+        }
+
+        return [$database, $queryAdapter];
+    }
+
+    private function createUsers(Database $database): void
+    {
+        $database->createCollection(new Collection(id: 'users', permissions: $this->permissions(), documentSecurity: false));
+        foreach (['a', 'b', 'c'] as $id) {
+            $database->createDocument('users', new Document(['$id' => $id]));
+        }
+    }
+
+    /**
+     * @param  callable(Database): mixed  $mutation
+     */
+    private function assertMutationRollsBackOnInvalidationFailure(callable $mutation, bool $sqlite = false): void
+    {
+        $adapter = $sqlite
+            ? new ObservedSQLite(new \PDO('sqlite::memory:'))
+            : new ObservedMemory();
+        $database = new Database($adapter, new Cache(new LeasableHashCache()));
+        $database
+            ->setDatabase('cache-tests')
+            ->setNamespace('cache_'.\uniqid());
+        $database->create();
+        $database->getAuthorization()->addRole(Role::any()->toString());
+        $database->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'name', required: true),
+        ], permissions: $this->permissions(), documentSecurity: false));
+        $database->createDocument('users', new Document([
+            '$id' => 'existing',
+            'name' => 'original',
+        ]));
+
+        $cache = new FailingMemory();
+        $database->setQueryCache(new QueryCache(new Cache($cache)));
+        $this->assertSame(
+            ['existing' => 'original'],
+            $this->names($database->find('users', [Query::orderAsc('$id')])),
+        );
+
+        $cache->seedEpoch('users');
+        $cache->failPurges();
+        try {
+            $mutation($database);
+            $this->fail('Mandatory invalidation failure was not propagated');
+        } catch (\RuntimeException $exception) {
+            $this->assertStringContainsString('query cache epoch', $exception->getMessage());
+        }
+
+        $adapter->observeFinds('users');
+        $this->assertSame(
+            ['existing' => 'original'],
+            $this->names($database->find('users', [Query::orderAsc('$id')])),
+        );
+        $this->assertSame(1, $adapter->getObservedFinds(), 'The stale cached query result must stay blocked');
+    }
+
+    /**
+     * @return array{Database, Database, PausedSQLite, ObservedSQLite, LeasableHashCache, string}
+     */
+    private function createSharedSQLiteDatabases(): array
+    {
+        $path = \tempnam(\sys_get_temp_dir(), 'database-query-cache-');
+        if ($path === false) {
+            throw new \RuntimeException('Failed to create SQLite test database');
+        }
+
+        $attributes = SQLite::getPDOAttributes();
+        $attributes[\PDO::ATTR_PERSISTENT] = false;
+        $writerConnection = new \PDO('sqlite:'.$path, null, null, $attributes);
+        $readerConnection = new \PDO('sqlite:'.$path, null, null, $attributes);
+        $writerConnection->exec('PRAGMA journal_mode = WAL');
+        $writerConnection->exec('PRAGMA busy_timeout = 1000');
+        $readerConnection->exec('PRAGMA busy_timeout = 1000');
+
+        $writerAdapter = new PausedSQLite($writerConnection);
+        $readerAdapter = new ObservedSQLite($readerConnection);
+        $writer = new Database($writerAdapter, new Cache(new None()));
+        $reader = new Database($readerAdapter, new Cache(new None()));
+        $namespace = 'shared_cache_'.\uniqid();
+        foreach ([$writer, $reader] as $database) {
+            $database
+                ->setDatabase('cache-tests')
+                ->setNamespace($namespace);
+        }
+
+        $writer->create();
+        $writer->getAuthorization()->addRole(Role::any()->toString());
+        $reader->getAuthorization()->addRole(Role::any()->toString());
+        $writer->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'name', required: true),
+        ], permissions: $this->permissions(), documentSecurity: false));
+        $writer->createDocument('users', new Document([
+            '$id' => 'existing',
+            'name' => 'original',
+        ]));
+
+        $cache = new LeasableHashCache();
+        $writer->setQueryCache(new QueryCache(new Cache($cache)));
+        $reader->setQueryCache(new QueryCache(new Cache($cache)));
+
+        return [$writer, $reader, $writerAdapter, $readerAdapter, $cache, $path];
+    }
+
+    private function removeSQLiteFiles(string $path): void
+    {
+        foreach ([$path, $path.'-wal', $path.'-shm'] as $file) {
+            if (\is_file($file)) {
+                \unlink($file);
+            }
+        }
+    }
+
+    /** @return array<string> */
+    private function permissions(): array
+    {
+        return [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ];
+    }
+
+    /**
+     * @param array<Document> $documents
+     * @return array<string>
+     */
+    private function ids(array $documents): array
+    {
+        return \array_map(
+            static fn (Document $document): string => $document->getId(),
+            $documents,
+        );
+    }
+
+    /**
+     * @param  array<Document>  $documents
+     * @return array<string, string>
+     */
+    private function names(array $documents): array
+    {
+        $names = [];
+        foreach ($documents as $document) {
+            $name = $document->getAttribute('name');
+            if (! \is_string($name)) {
+                throw new \UnexpectedValueException('Expected document name to be a string');
+            }
+            $names[$document->getId()] = $name;
+        }
+
+        return $names;
+    }
+}
+
+final class LeasableHashCache implements CacheAdapter, Leasable
+{
+    /** @var array<string, array<string, array{time: int, data: array<int|string, mixed>|string}>> */
+    private array $store = [];
+
+    /** @var array<string, int> */
+    private array $generations = [];
+
+    /** @var array<string, int> */
+    private array $purges = [];
+
+    /** @var array<string, int> */
+    private array $writes = [];
+
+    private bool $failActivations = false;
+
+    public function load(string $key, int $ttl, string $hash = ''): mixed
+    {
+        $hash = $hash === '' ? $key : $hash;
+        $saved = $this->store[$key][$hash] ?? null;
+
+        return $saved !== null && $saved['time'] + $ttl > \time() ? $saved['data'] : false;
+    }
+
+    public function save(string $key, array|string $data, string $hash = ''): bool|string|array
+    {
+        if ($key === '') {
+            return false;
+        }
+
+        if (
+            $this->failActivations
+            && \str_ends_with($key, '#epoch')
+            && \is_string($data)
+            && \str_starts_with($data, 'active:')
+        ) {
+            return false;
+        }
+
+        $hash = $hash === '' ? $key : $hash;
+        $this->writes[$key] = ($this->writes[$key] ?? 0) + 1;
+        $this->store[$key][$hash] = ['time' => \time(), 'data' => $data];
+
+        return $data;
+    }
+
+    public function getGeneration(string $key): string
+    {
+        return (string) ($this->generations[$key] ?? 0);
+    }
+
+    public function saveWithLease(string $key, array|string $data, string $hash, string $generation): bool|string|array
+    {
+        if ($this->getGeneration($key) !== $generation) {
+            return false;
+        }
+
+        return $this->save($key, $data, $hash);
+    }
+
+    public function touch(string $key, string $hash = ''): bool
+    {
+        $hash = $hash === '' ? $key : $hash;
+        if (! isset($this->store[$key][$hash])) {
+            return false;
+        }
+
+        $this->store[$key][$hash]['time'] = \time();
+
+        return true;
+    }
+
+    /** @return array<string> */
+    public function list(string $key): array
+    {
+        return \array_keys($this->store[$key] ?? []);
+    }
+
+    public function purge(string $key, string $hash = ''): bool
+    {
+        $this->purges[$key] = ($this->purges[$key] ?? 0) + 1;
+        $this->generations[$key] = ($this->generations[$key] ?? 0) + 1;
+
+        if ($hash === '') {
+            unset($this->store[$key]);
+        } else {
+            unset($this->store[$key][$hash]);
+        }
+
+        return true;
+    }
+
+    public function flush(): bool
+    {
+        $this->store = [];
+        $this->generations = [];
+
+        return true;
+    }
+
+    public function ping(): bool
+    {
+        return true;
+    }
+
+    public function getSize(): int
+    {
+        return \count($this->store);
+    }
+
+    public function getName(?string $key = null): string
+    {
+        return 'leasable-hash';
+    }
+
+    public function resetPurges(): void
+    {
+        $this->purges = [];
+        $this->writes = [];
+    }
+
+    public function getPurges(string $key): int
+    {
+        return $this->purges[$key] ?? 0;
+    }
+
+    public function getWrites(string $key): int
+    {
+        return $this->writes[$key] ?? 0;
+    }
+
+    public function failActivations(): void
+    {
+        $this->failActivations = true;
+    }
+}
+
+final class ObservedMemory extends DatabaseMemory
+{
+    private ?Closure $metadataCallback = null;
+
+    private ?Closure $validatorCallback = null;
+
+    private ?string $metadataCollection = null;
+
+    private ?string $findCollection = null;
+
+    private int $metadataReads = 0;
+
+    private int $validators = 0;
+
+    private int $finds = 0;
+
+    public function observeMetadata(string $collection, Closure $callback): void
+    {
+        $this->metadataCollection = $collection;
+        $this->metadataCallback = $callback;
+        $this->metadataReads = 0;
+    }
+
+    public function observeValidators(Closure $callback): void
+    {
+        $this->validatorCallback = $callback;
+        $this->validators = 0;
+    }
+
+    public function observeFinds(string $collection): void
+    {
+        $this->findCollection = $collection;
+        $this->finds = 0;
+    }
+
+    public function getObservedMetadataReads(): int
+    {
+        return $this->metadataReads;
+    }
+
+    public function getObservedValidators(): int
+    {
+        return $this->validators;
+    }
+
+    public function getObservedFinds(): int
+    {
+        return $this->finds;
+    }
+
+    #[\Override]
+    public function getDocument(Document $collection, string $id, array $queries = [], bool $forUpdate = false): Document
+    {
+        $document = parent::getDocument($collection, $id, $queries, $forUpdate);
+
+        if ($collection->getId() === Database::METADATA && $id === $this->metadataCollection) {
+            $this->metadataReads++;
+            $callback = $this->metadataCallback;
+            $this->metadataCallback = null;
+            $callback?->__invoke();
+        }
+
+        return $document;
+    }
+
+    #[\Override]
+    public function getIdAttributeType(): string
+    {
+        if ($this->validatorCallback !== null) {
+            $this->validators++;
+            $callback = $this->validatorCallback;
+            $this->validatorCallback = null;
+            $callback();
+        } elseif ($this->validators > 0) {
+            $this->validators++;
+        }
+
+        return parent::getIdAttributeType();
+    }
+
+    #[\Override]
+    public function find(
+        Document $collection,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $orderAttributes = [],
+        array $orderTypes = [],
+        array $cursor = [],
+        CursorDirection $cursorDirection = CursorDirection::After,
+        PermissionType $forPermission = PermissionType::Read,
+    ): array {
+        if ($collection->getId() === $this->findCollection) {
+            $this->finds++;
+        }
+
+        return parent::find(
+            $collection,
+            $queries,
+            $limit,
+            $offset,
+            $orderAttributes,
+            $orderTypes,
+            $cursor,
+            $cursorDirection,
+            $forPermission,
+        );
+    }
+}
+
+final class ObservedSQLite extends SQLite
+{
+    private ?string $findCollection = null;
+
+    private int $finds = 0;
+
+    public function observeFinds(string $collection): void
+    {
+        $this->findCollection = $collection;
+        $this->finds = 0;
+    }
+
+    public function getObservedFinds(): int
+    {
+        return $this->finds;
+    }
+
+    #[\Override]
+    public function find(
+        Document $collection,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $orderAttributes = [],
+        array $orderTypes = [],
+        array $cursor = [],
+        CursorDirection $cursorDirection = CursorDirection::After,
+        PermissionType $forPermission = PermissionType::Read,
+    ): array {
+        if ($collection->getId() === $this->findCollection) {
+            $this->finds++;
+        }
+
+        return parent::find(
+            $collection,
+            $queries,
+            $limit,
+            $offset,
+            $orderAttributes,
+            $orderTypes,
+            $cursor,
+            $cursorDirection,
+            $forPermission,
+        );
+    }
+}
+
+final class PausedSQLite extends SQLite
+{
+    private ?Closure $commitCallback = null;
+
+    public function pauseNextCommit(Closure $callback): void
+    {
+        $this->commitCallback = $callback;
+    }
+
+    #[\Override]
+    public function commitTransaction(): bool
+    {
+        $callback = $this->commitCallback;
+        $this->commitCallback = null;
+        $callback?->__invoke();
+
+        return parent::commitTransaction();
+    }
+}
+
+final class JoinMemory extends DatabaseMemory
+{
+    private int $finds = 0;
+
+    #[\Override]
+    public function capabilities(): array
+    {
+        return [...parent::capabilities(), Capability::Joins];
+    }
+
+    #[\Override]
+    public function find(
+        Document $collection,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $orderAttributes = [],
+        array $orderTypes = [],
+        array $cursor = [],
+        CursorDirection $cursorDirection = CursorDirection::After,
+        PermissionType $forPermission = PermissionType::Read,
+    ): array {
+        if ($collection->getId() === 'parents') {
+            $this->finds++;
+        }
+
+        $queries = \array_values(\array_filter(
+            $queries,
+            static fn (Query $query): bool => ! \in_array($query->getMethod(), [
+                \Utopia\Query\Method::Join,
+                \Utopia\Query\Method::LeftJoin,
+                \Utopia\Query\Method::RightJoin,
+                \Utopia\Query\Method::CrossJoin,
+            ], true),
+        ));
+
+        return parent::find(
+            $collection,
+            $queries,
+            $limit,
+            $offset,
+            $orderAttributes,
+            $orderTypes,
+            $cursor,
+            $cursorDirection,
+            $forPermission,
+        );
+    }
+
+    public function getJoinFinds(): int
+    {
+        return $this->finds;
+    }
+}
+
+final class FailingMemory extends MemoryCache
+{
+    private bool $failing = false;
+
+    public function failPurges(): void
+    {
+        $this->failing = true;
+    }
+
+    public function seedEpoch(string $collection): void
+    {
+        $this->save('default:qcache:'.$collection.'#epoch', 'active:seed');
+    }
+
+    #[\Override]
+    public function purge(string $key, string $hash = ''): bool
+    {
+        if ($this->failing && \str_ends_with($key, '#epoch')) {
+            return false;
+        }
+
+        return parent::purge($key, $hash);
+    }
+}
diff --git a/tests/unit/Cache/QueryCacheTest.php b/tests/unit/Cache/QueryCacheTest.php
new file mode 100644
index 0000000000..19e3e96f53
--- /dev/null
+++ b/tests/unit/Cache/QueryCacheTest.php
@@ -0,0 +1,673 @@
+<?php
+
+namespace Tests\Unit\Cache;
+
+use Closure;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter as CacheAdapter;
+use Utopia\Cache\Adapter\Memory;
+use Utopia\Cache\Cache;
+use Utopia\Cache\Feature\Leasable;
+use Utopia\Database\Cache\Invalidator;
+use Utopia\Database\Cache\QueryCache;
+use Utopia\Database\Cache\Region;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Query;
+
+class QueryCacheTest extends TestCase
+{
+    private QueryCache $queryCache;
+
+    private Cache&Stub $cache;
+
+    protected function setUp(): void
+    {
+        $this->cache = self::createStub(Cache::class);
+        $this->queryCache = new QueryCache($this->cache);
+    }
+
+    public function testConstructorWithDefaults(): void
+    {
+        $cache = self::createStub(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $this->assertTrue($queryCache->isEnabled('any_collection'));
+    }
+
+    public function testConstructorWithCustomName(): void
+    {
+        $cache = self::createStub(Cache::class);
+        $queryCache = new QueryCache($cache, 'custom');
+        $key = $queryCache->buildQueryKey('users', [], 'ns', null);
+        $this->assertStringStartsWith('custom:', $key);
+    }
+
+    public function testSetRegionAndGetRegion(): void
+    {
+        $region = new Region(ttl: 600, enabled: false);
+        $this->queryCache->setRegion('users', $region);
+        $retrieved = $this->queryCache->getRegion('users');
+        $this->assertSame($region, $retrieved);
+    }
+
+    public function testGetRegionReturnsDefaultForUnknownCollection(): void
+    {
+        $region = $this->queryCache->getRegion('unknown');
+        $this->assertEquals(3600, $region->ttl);
+        $this->assertTrue($region->enabled);
+    }
+
+    public function testBuildQueryKeyGeneratesConsistentKeys(): void
+    {
+        $queries = [Query::equal('status', ['active'])];
+        $key1 = $this->queryCache->buildQueryKey('users', $queries, 'ns', 1);
+        $key2 = $this->queryCache->buildQueryKey('users', $queries, 'ns', 1);
+        $this->assertEquals($key1, $key2);
+    }
+
+    public function testBuildQueryKeyIncludesNamespaceAndTenant(): void
+    {
+        $key = $this->queryCache->buildQueryKey('users', [], 'myns', 42);
+        $differentNamespace = $this->queryCache->buildQueryKey('users', [], 'other', 42);
+        $differentTenant = $this->queryCache->buildQueryKey('users', [], 'myns', 43);
+
+        $this->assertNotSame($key, $differentNamespace);
+        $this->assertNotSame($key, $differentTenant);
+    }
+
+    public function testBuildQueryKeyPreservesTenantType(): void
+    {
+        $integer = $this->queryCache->buildQueryKey('users', [], 'ns', 1);
+        $string = $this->queryCache->buildQueryKey('users', [], 'ns', '1');
+
+        $this->assertNotSame($integer, $string);
+    }
+
+    public function testBuildQueryKeyDifferentQueriesProduceDifferentKeys(): void
+    {
+        $key1 = $this->queryCache->buildQueryKey('users', [Query::equal('a', [1])], 'ns', null);
+        $key2 = $this->queryCache->buildQueryKey('users', [Query::equal('b', [2])], 'ns', null);
+        $this->assertNotEquals($key1, $key2);
+    }
+
+    public function testBuildQueryKeyDifferentCollectionsProduceDifferentKeys(): void
+    {
+        $key1 = $this->queryCache->buildQueryKey('users', [], 'ns', null);
+        $key2 = $this->queryCache->buildQueryKey('posts', [], 'ns', null);
+        $this->assertNotEquals($key1, $key2);
+    }
+
+    public function testGetReturnsNullForCacheMiss(): void
+    {
+        $this->cache->method('load')->willReturn(false);
+        $result = $this->queryCache->get('some-key');
+        $this->assertNull($result);
+    }
+
+    public function testGetReturnsNullForNullData(): void
+    {
+        $this->cache->method('load')->willReturn(null);
+        $result = $this->queryCache->get('some-key');
+        $this->assertNull($result);
+    }
+
+    public function testGetReturnsDocumentArrayForCacheHit(): void
+    {
+        $this->cache->method('load')->willReturn(
+            'active:epoch',
+            [
+                'version' => 1,
+                'documents' => [
+                    ['$id' => 'doc1', 'name' => 'Alice'],
+                    ['$id' => 'doc2', 'name' => 'Bob'],
+                ],
+            ],
+            'active:epoch',
+        );
+
+        $result = $this->queryCache->get('some-key');
+
+        $this->assertNotNull($result);
+        $this->assertCount(2, $result);
+        $this->assertEquals('doc1', $result[0]->getId());
+    }
+
+    public function testGetHandlesDocumentObjectsInCache(): void
+    {
+        $doc = new Document(['$id' => 'doc1', 'name' => 'Alice']);
+        $this->cache->method('load')->willReturn(
+            'active:epoch',
+            [
+                'version' => 1,
+                'documents' => [$doc],
+            ],
+            'active:epoch',
+        );
+
+        $result = $this->queryCache->get('some-key');
+
+        $this->assertNotNull($result);
+        $this->assertCount(1, $result);
+        $this->assertSame($doc, $result[0]);
+    }
+
+    public function testGetPropagatesMalformedPayloadPurgeFailure(): void
+    {
+        $this->cache->method('load')->willReturn('active:epoch', 'not-an-array', 'active:epoch');
+
+        $this->expectException(\RuntimeException::class);
+        $this->queryCache->get('some-key');
+    }
+
+    public function testGetUsesCollectionRegionTtlAndQueryHash(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $queryCache->setRegion('users', new Region(ttl: 120));
+        $key = $queryCache->buildQueryKey('users', [Query::limit(10)], 'ns', null);
+        [, $hash] = \explode('#', $key, 2);
+
+        $cache->expects($this->exactly(2))
+            ->method('load')
+            ->willReturnCallback(function (string $cacheKey, int $ttl) use ($hash): string|false {
+                $this->assertSame(120, $ttl);
+
+                return match ($cacheKey) {
+                    'default:qcache:users#epoch' => 'active:epoch',
+                    'default:qcache:users#active:epoch:'.$hash => false,
+                    default => throw new \LogicException("Unexpected cache key '{$cacheKey}'"),
+                };
+            });
+
+        $this->assertNull($queryCache->get($key));
+    }
+
+    public function testGetPurgesMalformedPayload(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $key = $queryCache->buildQueryKey('users', [], 'ns', null);
+        [, $hash] = \explode('#', $key, 2);
+
+        $cache->method('load')->willReturnOnConsecutiveCalls(
+            'active:epoch',
+            ['version' => 1, 'documents' => ['invalid']],
+            'active:epoch',
+        );
+        $cache->expects($this->once())
+            ->method('purge')
+            ->with('default:qcache:users#active:epoch:'.$hash)
+            ->willReturn(true);
+
+        $this->assertNull($queryCache->get($key));
+    }
+
+    public function testSetSerializesDocuments(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $cache->method('load')->willReturn('active:epoch');
+        $cache->method('getGeneration')->willReturn('0');
+
+        $docs = [
+            new Document(['$id' => 'doc1', 'name' => 'Alice']),
+        ];
+
+        $cache->expects($this->once())
+            ->method('saveWithLease')
+            ->with(
+                'cache-key#active:epoch:',
+                $this->callback(function (array $data): bool {
+                    $documents = $data['documents'] ?? null;
+
+                    return ($data['version'] ?? null) === 1
+                        && \is_array($documents)
+                        && \is_array($documents[0] ?? null)
+                        && ($documents[0]['$id'] ?? null) === 'doc1';
+                }),
+                '',
+                '0',
+            );
+
+        $queryCache->set('cache-key', $docs);
+    }
+
+    public function testInvalidateCollectionCallsPurge(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+
+        $queryCache->invalidateCollection('users');
+
+        $this->assertSame(1, $cache->getPurges('default:qcache:users#epoch'));
+    }
+
+    public function testIsEnabledReturnsTrueByDefault(): void
+    {
+        $this->assertTrue($this->queryCache->isEnabled('any'));
+    }
+
+    public function testIsEnabledReturnsFalseWhenRegionDisabled(): void
+    {
+        $this->queryCache->setRegion('users', new Region(enabled: false));
+        $this->assertFalse($this->queryCache->isEnabled('users'));
+    }
+
+    public function testFlushDelegatesToCacheFlush(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+
+        $cache->expects($this->once())
+            ->method('flush')
+            ->willReturn(true);
+
+        $queryCache->flush();
+    }
+
+    public function testRegionDefaults(): void
+    {
+        $region = new Region();
+        $this->assertEquals(3600, $region->ttl);
+        $this->assertTrue($region->enabled);
+    }
+
+    public function testRegionCustomValues(): void
+    {
+        $region = new Region(ttl: 120, enabled: false);
+        $this->assertEquals(120, $region->ttl);
+        $this->assertFalse($region->enabled);
+    }
+
+    public function testInvalidatorInvalidatesOnDocumentCreate(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $invalidator->handle(Event::DocumentCreate, $doc);
+        $this->assertSame(1, $cache->getPurges('default:qcache:users#epoch'));
+    }
+
+    public function testInvalidatorInvalidatesOnDocumentUpdate(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'posts']);
+
+        $invalidator->handle(Event::DocumentUpdate, $doc);
+        $this->assertSame(1, $cache->getPurges('default:qcache:posts#epoch'));
+    }
+
+    public function testInvalidatorInvalidatesOnDocumentDelete(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $invalidator->handle(Event::DocumentDelete, $doc);
+        $this->assertSame(1, $cache->getPurges('default:qcache:users#epoch'));
+    }
+
+    public function testInvalidatorIgnoresNonWriteEvents(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $cache->expects($this->never())->method('purge');
+        $invalidator->handle(Event::DocumentFind, $doc);
+    }
+
+    public function testInvalidatorExtractsCollectionFromDocument(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'orders']);
+        $invalidator->handle(Event::DocumentCreate, $doc);
+        $this->assertSame(1, $cache->getPurges('default:qcache:orders#epoch'));
+    }
+
+    public function testInvalidatorHandlesStringData(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $invalidator->handle(Event::DocumentCreate, 'products');
+        $this->assertSame(1, $cache->getPurges('default:qcache:products#epoch'));
+    }
+
+    public function testInvalidatorIgnoresEmptyCollection(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1']);
+
+        $cache->expects($this->never())->method('purge');
+        $invalidator->handle(Event::DocumentCreate, $doc);
+    }
+
+    public function testInvalidatorInvalidatesBothRelationshipCollections(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $invalidator->handle(Event::AttributeCreate, new Document([
+            '$collection' => 'posts',
+            'options' => [
+                'relatedCollection' => 'authors',
+            ],
+        ]));
+
+        $this->assertSame(1, $cache->getPurges('default:qcache:posts#epoch'));
+        $this->assertSame(1, $cache->getPurges('default:qcache:authors#epoch'));
+    }
+
+    public function testInvalidatorUsesCollectionIdentityForCollectionMutations(): void
+    {
+        $cache = new InvalidationCache();
+        $queryCache = new QueryCache($cache);
+        $invalidator = new Invalidator($queryCache);
+
+        $invalidator->handle(Event::CollectionUpdate, new Document([
+            '$id' => 'users',
+            '$collection' => Database::METADATA,
+        ]));
+        $this->assertSame(1, $cache->getPurges('default:qcache:users#epoch'));
+    }
+
+    public function testMemoryAdapterKeepsPhysicalVariantsIsolated(): void
+    {
+        $queryCache = new QueryCache(new Cache(new Memory()));
+        $firstKey = $queryCache->buildQueryKey('users', [['limit' => 1]], 'ns', null, 'role:user-a');
+        $secondKey = $queryCache->buildQueryKey('users', [['limit' => 2]], 'ns', null, 'role:user-b');
+
+        $firstGeneration = $queryCache->getGeneration($firstKey);
+        $secondGeneration = $queryCache->getGeneration($secondKey);
+
+        $this->assertTrue($queryCache->set($firstKey, [new Document(['$id' => 'private-a'])], $firstGeneration));
+        $this->assertTrue($queryCache->set($secondKey, [new Document(['$id' => 'private-b'])], $secondGeneration));
+        $first = $queryCache->get($firstKey);
+        $second = $queryCache->get($secondKey);
+        $this->assertNotNull($first);
+        $this->assertNotNull($second);
+        $this->assertSame('private-a', $first[0]->getId());
+        $this->assertSame('private-b', $second[0]->getId());
+    }
+
+    public function testMemoryAdapterStaysBlockedAfterInvalidation(): void
+    {
+        $queryCache = new QueryCache(new Cache(new Memory()));
+        $key = $queryCache->buildQueryKey('users', [], 'ns', null);
+        $generation = $queryCache->getGeneration($key);
+
+        $this->assertTrue($queryCache->set($key, [new Document(['$id' => 'old'])], $generation));
+        $documents = $queryCache->get($key);
+        $this->assertNotNull($documents);
+        $this->assertSame('old', $documents[0]->getId());
+
+        $queryCache->invalidateCollection('users');
+
+        $this->assertFalse($queryCache->isEnabled('users'));
+        $this->assertNull($queryCache->get($key));
+        $this->assertFalse($queryCache->set($key, [new Document(['$id' => 'new'])]));
+    }
+
+    public function testConcurrentOwnersCannotEnableCacheEarly(): void
+    {
+        for ($iteration = 0; $iteration < 10; $iteration++) {
+            $adapter = new OwnershipCache();
+            $first = new QueryCache(new Cache($adapter));
+            $second = new QueryCache(new Cache($adapter));
+            $reader = new QueryCache(new Cache($adapter));
+            $key = $reader->buildQueryKey('users', [], 'ns', null);
+            $firstToken = 'first-'.$iteration;
+            $secondToken = 'second-'.$iteration;
+
+            $generation = $reader->getGeneration($key);
+            $this->assertTrue($reader->set($key, [new Document(['$id' => 'old'])], $generation));
+            $documents = (new QueryCache(new Cache($adapter)))->get($key);
+            $this->assertNotNull($documents);
+            $this->assertSame('old', $documents[0]->getId());
+
+            $first->blockCollection('users', $firstToken);
+            $adapter->pauseNextActivation(function () use ($adapter, $reader, $second, $secondToken): void {
+                $second->blockCollection('users', $secondToken);
+
+                $this->assertFalse($reader->isEnabled('users'));
+                $this->assertNull($reader->get($reader->buildQueryKey('users', [], 'ns', null)));
+                $this->assertTrue($adapter->has('default:qcache:users#owner:'.$secondToken));
+            });
+
+            $first->activateCollection('users', $firstToken);
+
+            $this->assertFalse($adapter->has('default:qcache:users#owner:'.$firstToken));
+            $this->assertTrue($adapter->has('default:qcache:users#owner:'.$secondToken));
+            $this->assertFalse($reader->isEnabled('users'));
+            $this->assertNull($reader->get($key));
+
+            $second->activateCollection('users', $secondToken);
+
+            $this->assertFalse($adapter->has('default:qcache:users#owner:'.$secondToken));
+            $this->assertTrue($reader->isEnabled('users'));
+            $this->assertNull($reader->get($key));
+            $generation = $reader->getGeneration($key);
+            $this->assertTrue($reader->set($key, [new Document(['$id' => 'fresh'])], $generation));
+            $this->assertSame(
+                ['fresh'],
+                \array_map(
+                    static fn (Document $document): string => (string) $document->getId(),
+                    (new QueryCache(new Cache($adapter)))->get($key) ?? [],
+                ),
+            );
+        }
+    }
+
+    public function testInvalidationPropagatesPurgeFailure(): void
+    {
+        $cache = new InvalidationCache();
+        $cache->fail('default:qcache:users#epoch');
+
+        $this->expectException(\RuntimeException::class);
+        (new QueryCache($cache))->invalidateCollection('users');
+    }
+
+}
+
+final class InvalidationCache extends Cache
+{
+    /** @var array<string, string> */
+    public array $values = [];
+
+    /** @var array<string, int> */
+    public array $generations = [];
+
+    /** @var array<string, int> */
+    public array $purges = [];
+
+    /** @var array<string, true> */
+    public array $failures = [];
+
+    public function __construct()
+    {
+        parent::__construct(new Memory());
+    }
+
+    #[\Override]
+    public function load(string $key, int $ttl, string $hash = ''): mixed
+    {
+        if (isset($this->values[$key])) {
+            return $this->values[$key];
+        }
+
+        return \str_ends_with($key, '#epoch') ? 'active:epoch' : false;
+    }
+
+    #[\Override]
+    public function save(string $key, mixed $data, string $hash = ''): string|array
+    {
+        if (\is_string($data)) {
+            $this->values[$key] = $data;
+        }
+
+        return $data;
+    }
+
+    #[\Override]
+    public function getGeneration(string $key): string
+    {
+        return (string) ($this->generations[$key] ?? 0);
+    }
+
+    #[\Override]
+    public function purge(string $key, string $hash = ''): bool
+    {
+        $this->purges[$key] = ($this->purges[$key] ?? 0) + 1;
+        if (isset($this->failures[$key])) {
+            return false;
+        }
+
+        $this->generations[$key] = ($this->generations[$key] ?? 0) + 1;
+        unset($this->values[$key]);
+
+        return true;
+    }
+
+    public function fail(string $key): void
+    {
+        $this->failures[$key] = true;
+    }
+
+    public function getPurges(string $key): int
+    {
+        return $this->purges[$key] ?? 0;
+    }
+}
+
+final class OwnershipCache implements CacheAdapter, Leasable
+{
+    /** @var array<string, array{time: int, data: array<int|string, mixed>|string}> */
+    private array $store = [];
+
+    /** @var array<string, int> */
+    private array $generations = [];
+
+    private ?Closure $activation = null;
+
+    public function load(string $key, int $ttl, string $hash = ''): mixed
+    {
+        $saved = $this->store[$key] ?? null;
+
+        return $saved !== null && $saved['time'] + $ttl > \time() ? $saved['data'] : false;
+    }
+
+    public function save(string $key, array|string $data, string $hash = ''): bool|string|array
+    {
+        if ($key === '') {
+            return false;
+        }
+
+        if (
+            $this->activation !== null
+            && \str_ends_with($key, '#epoch')
+            && \is_string($data)
+            && \str_starts_with($data, 'active:')
+        ) {
+            $activation = $this->activation;
+            $this->activation = null;
+            $activation();
+        }
+
+        $this->store[$key] = ['time' => \time(), 'data' => $data];
+
+        return $data;
+    }
+
+    public function getGeneration(string $key): string
+    {
+        return (string) ($this->generations[$key] ?? 0);
+    }
+
+    public function saveWithLease(string $key, array|string $data, string $hash, string $generation): bool|string|array
+    {
+        if ($this->getGeneration($key) !== $generation) {
+            return false;
+        }
+
+        return $this->save($key, $data, $hash);
+    }
+
+    public function touch(string $key, string $hash = ''): bool
+    {
+        if (! isset($this->store[$key])) {
+            return false;
+        }
+
+        $this->store[$key]['time'] = \time();
+
+        return true;
+    }
+
+    /** @return array<string> */
+    public function list(string $key): array
+    {
+        return [];
+    }
+
+    public function purge(string $key, string $hash = ''): bool
+    {
+        $this->generations[$key] = ($this->generations[$key] ?? 0) + 1;
+        unset($this->store[$key]);
+
+        return true;
+    }
+
+    public function flush(): bool
+    {
+        $this->store = [];
+        $this->generations = [];
+
+        return true;
+    }
+
+    public function ping(): bool
+    {
+        return true;
+    }
+
+    public function getSize(): int
+    {
+        return \count($this->store);
+    }
+
+    public function getName(?string $key = null): string
+    {
+        return 'ownership';
+    }
+
+    public function has(string $key): bool
+    {
+        return isset($this->store[$key]);
+    }
+
+    public function pauseNextActivation(Closure $activation): void
+    {
+        $this->activation = $activation;
+    }
+}
diff --git a/tests/unit/CacheKeyTest.php b/tests/unit/CacheKeyTest.php
index 92c3bc6082..8300cfbca6 100644
--- a/tests/unit/CacheKeyTest.php
+++ b/tests/unit/CacheKeyTest.php
@@ -2,15 +2,21 @@
 
 namespace Tests\Unit;
 
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
 use PHPUnit\Framework\TestCase;
 use Utopia\Cache\Adapter\None;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Hook\Relationships;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
 
+#[AllowMockObjectsWithoutExpectations]
 class CacheKeyTest extends TestCase
 {
     /**
@@ -19,7 +25,12 @@ class CacheKeyTest extends TestCase
     private function createDatabase(array $instanceFilters = [], string $database = 'test'): Database
     {
         $adapter = $this->createMock(Adapter::class);
-        $adapter->method('getSupportForHostname')->willReturn(false);
+        $adapter->method('supports')->willReturnCallback(function (Capability $capability) {
+            return match ($capability) {
+                Capability::Hostname => false,
+                default => false,
+            };
+        });
         $adapter->method('getTenant')->willReturn(null);
         $adapter->method('getNamespace')->willReturn('test');
         $adapter->method('getDatabase')->willReturn($database);
@@ -138,7 +149,9 @@ public function testFiltersDisabledEntirelyProducesDifferentCacheKey(): void
     public function testQueryCacheKeyUsesQueryCacheShape(): void
     {
         $adapter = $this->createMock(Adapter::class);
-        $adapter->method('getSupportForHostname')->willReturn(true);
+        $adapter->method('supports')->willReturnCallback(
+            fn (Capability $capability): bool => $capability === Capability::Hostname
+        );
         $adapter->method('getHostname')->willReturn('mysql-console');
         $adapter->method('getNamespace')->willReturn('_39');
         $adapter->method('getTenant')->willReturn(null);
@@ -154,7 +167,9 @@ public function testQueryCacheKeyUsesQueryCacheShape(): void
     public function testQueryCacheKeyCanOverrideNamespaceSegment(): void
     {
         $adapter = $this->createMock(Adapter::class);
-        $adapter->method('getSupportForHostname')->willReturn(true);
+        $adapter->method('supports')->willReturnCallback(
+            fn (Capability $capability): bool => $capability === Capability::Hostname
+        );
         $adapter->method('getHostname')->willReturn('mysql-console');
         $adapter->method('getNamespace')->willReturn('');
         $adapter->method('getTenant')->willReturn(null);
@@ -173,8 +188,8 @@ public function testQueryCacheFieldUsesQueryCacheShape(): void
         $collection = new Document([
             '$id' => 'wafRules',
             'attributes' => [
-                new Document(['$id' => 'projectId', 'type' => Database::VAR_STRING]),
-                new Document(['$id' => 'enabled', 'type' => Database::VAR_BOOLEAN]),
+                new Document(['$id' => 'projectId', 'type' => ColumnType::String->value]),
+                new Document(['$id' => 'enabled', 'type' => ColumnType::Boolean->value]),
             ],
             'indexes' => [
                 new Document(['$id' => 'project_enabled', 'attributes' => ['projectId', 'enabled']]),
@@ -187,12 +202,13 @@ public function testQueryCacheFieldUsesQueryCacheShape(): void
         ];
 
         $schemaHash = \md5(
-            (\json_encode($collection->getAttribute('attributes', [])) ?: '')
-            . (\json_encode($collection->getAttribute('indexes', [])) ?: '')
+            (\json_encode($collection->getArray('attributes')) ?: '')
+            . (\json_encode($collection->getArray('indexes')) ?: '')
             . (\json_encode($collection->getAttribute('$permissions', [])) ?: '')
             . (\json_encode($collection->getAttribute('documentSecurity', false)) ?: '')
         );
         $field = $db->getQueryCacheField($collection, $queries);
+        $this->assertNotNull($field);
 
         $this->assertStringStartsWith("{$schemaHash}:", $field);
         $this->assertStringEndsWith(':documents', $field);
@@ -205,24 +221,27 @@ public function testQueryCacheFieldChangesWithInputs(): void
 
         $field = $db->getQueryCacheField(
             new Document([
-                'attributes' => [new Document(['$id' => 'name', 'type' => Database::VAR_STRING])],
+                'attributes' => [new Document(['$id' => 'name', 'type' => ColumnType::String->value])],
                 'indexes' => [],
             ]),
             [Query::limit(10)],
         );
+        $this->assertNotNull($field);
 
         $this->assertNotSame(
             $field,
             $db->getQueryCacheField(
                 new Document([
-                    'attributes' => [new Document(['$id' => 'status', 'type' => Database::VAR_STRING])],
+                    'attributes' => [new Document(['$id' => 'status', 'type' => ColumnType::String->value])],
                     'indexes' => [],
                 ]),
                 [Query::limit(10)],
             ),
         );
         $this->assertNotSame($field, $db->getQueryCacheField(null, [Query::limit(20)]));
-        $this->assertStringEndsWith(':total', $db->getQueryCacheField(null, [Query::limit(10)], 'total'));
+        $total = $db->getQueryCacheField(null, [Query::limit(10)], 'total');
+        $this->assertNotNull($total);
+        $this->assertStringEndsWith(':total', $total);
     }
 
     public function testQueryCacheFieldChangesWithActiveAuthorizationContext(): void
@@ -248,7 +267,7 @@ public function testQueryCacheFieldReturnsNullForNonReadPermission(): void
     {
         $db = $this->createDatabase();
 
-        $this->assertNull($db->getQueryCacheField(forPermission: Database::PERMISSION_UPDATE));
+        $this->assertNull($db->getQueryCacheField(forPermission: PermissionType::Update));
     }
 
     public function testQueryCacheFieldIncludesCursorDocumentPayload(): void
@@ -276,6 +295,7 @@ public function testQueryCacheFieldIncludesCursorDocumentPayload(): void
     public function testQueryCacheFieldIncludesAmbientState(): void
     {
         $db = $this->createDatabase();
+        $db->addHook(new Relationships($db));
 
         $field = $db->getQueryCacheField(null, [Query::limit(10)]);
 
@@ -306,7 +326,12 @@ public function testParseHostname(): void
         $hostname = 'database_db_nyc3_self_hosted_0_0';
 
         $adapter = $this->createMock(Adapter::class);
-        $adapter->method('getSupportForHostname')->willReturn(true);
+        $adapter->method('supports')->willReturnCallback(function (Capability $capability) {
+            return match ($capability) {
+                Capability::Hostname => true,
+                default => false,
+            };
+        });
         $adapter->method('getHostname')->willReturn($hostname);
         $adapter->method('getTenant')->willReturn(999);
         $adapter->method('getSharedTables')->willReturn(true);
diff --git a/tests/unit/ChangeTest.php b/tests/unit/ChangeTest.php
new file mode 100644
index 0000000000..a236f435fb
--- /dev/null
+++ b/tests/unit/ChangeTest.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Change;
+use Utopia\Database\Document;
+
+class ChangeTest extends TestCase
+{
+    public function testConstructorWithOldAndNew(): void
+    {
+        $old = new Document(['$id' => 'doc1', 'name' => 'Old Name']);
+        $new = new Document(['$id' => 'doc1', 'name' => 'New Name']);
+
+        $change = new Change($old, $new);
+
+        $this->assertSame($old, $change->getOld());
+        $this->assertSame($new, $change->getNew());
+    }
+
+    public function testGetOldAndGetNew(): void
+    {
+        $old = new Document(['$id' => 'test', 'status' => 'draft']);
+        $new = new Document(['$id' => 'test', 'status' => 'published']);
+
+        $change = new Change($old, $new);
+
+        $this->assertSame('draft', $change->getOld()->getAttribute('status'));
+        $this->assertSame('published', $change->getNew()->getAttribute('status'));
+        $this->assertSame('test', $change->getOld()->getId());
+        $this->assertSame('test', $change->getNew()->getId());
+    }
+
+    public function testSetOld(): void
+    {
+        $old = new Document(['$id' => 'doc', 'val' => 1]);
+        $new = new Document(['$id' => 'doc', 'val' => 2]);
+        $change = new Change($old, $new);
+
+        $replacement = new Document(['$id' => 'doc', 'val' => 0]);
+        $change->setOld($replacement);
+
+        $this->assertSame($replacement, $change->getOld());
+        $this->assertSame(0, $change->getOld()->getAttribute('val'));
+        $this->assertSame($new, $change->getNew());
+    }
+
+    public function testSetNew(): void
+    {
+        $old = new Document(['$id' => 'doc', 'val' => 1]);
+        $new = new Document(['$id' => 'doc', 'val' => 2]);
+        $change = new Change($old, $new);
+
+        $replacement = new Document(['$id' => 'doc', 'val' => 99]);
+        $change->setNew($replacement);
+
+        $this->assertSame($old, $change->getOld());
+        $this->assertSame($replacement, $change->getNew());
+        $this->assertSame(99, $change->getNew()->getAttribute('val'));
+    }
+
+    public function testWithEmptyDocuments(): void
+    {
+        $old = new Document();
+        $new = new Document();
+
+        $change = new Change($old, $new);
+
+        $this->assertTrue($change->getOld()->isEmpty());
+        $this->assertTrue($change->getNew()->isEmpty());
+    }
+}
diff --git a/tests/unit/CollectionDefinitionTest.php b/tests/unit/CollectionDefinitionTest.php
new file mode 100644
index 0000000000..4ab23873ad
--- /dev/null
+++ b/tests/unit/CollectionDefinitionTest.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+
+final class CollectionDefinitionTest extends TestCase
+{
+    public function testCollectionDefinitionHasNoExternalId(): void
+    {
+        $def = Database::collectionDefinition();
+        [$definition, $attributes] = $this->resolve($def);
+
+        $keys = [];
+        foreach ($attributes as $attribute) {
+            $keys[] = $this->fields($attribute)['key'];
+        }
+
+        $this->assertNotContains('externalId', $keys);
+        $this->assertSame(false, \array_key_exists('externalId', $definition));
+    }
+
+    public function testCollectionDefinitionKeys(): void
+    {
+        $def = Database::collectionDefinition();
+        [$definition, $attributes] = $this->resolve($def);
+
+        $keys = [];
+        foreach ($attributes as $attribute) {
+            $keys[] = $this->fields($attribute)['key'];
+        }
+
+        $this->assertSame(Database::METADATA, $definition[Document::ID]);
+        $this->assertSame(Database::METADATA, $definition[Document::COLLECTION]);
+        $this->assertSame('collections', $definition['name']);
+        $this->assertSame(['name', 'attributes', 'indexes', 'documentSecurity'], $keys);
+    }
+
+    public function testCollectionDefinitionAttributeTypes(): void
+    {
+        $def = Database::collectionDefinition();
+        [, $attributes] = $this->resolve($def);
+
+        $byKey = [];
+        foreach ($attributes as $attribute) {
+            $fields = $this->fields($attribute);
+            $byKey[$fields['key']] = $fields;
+        }
+
+        $this->assertSame('string', $byKey['name']['type']);
+        $this->assertSame(256, $byKey['name']['size']);
+        $this->assertSame(true, $byKey['name']['required']);
+
+        $this->assertSame('string', $byKey['attributes']['type']);
+        $this->assertSame(1000000, $byKey['attributes']['size']);
+        $this->assertSame(true, \in_array('json', $byKey['attributes']['filters'], true));
+
+        $this->assertSame('string', $byKey['indexes']['type']);
+        $this->assertSame(1000000, $byKey['indexes']['size']);
+        $this->assertSame(true, \in_array('json', $byKey['indexes']['filters'], true));
+
+        $this->assertSame('boolean', $byKey['documentSecurity']['type']);
+        $this->assertSame(true, $byKey['documentSecurity']['required']);
+    }
+
+    public function testMetadataSchemaHasNoExternalId(): void
+    {
+        $db = new Database(new Memory(), new Cache(new None()));
+        $db->setDatabase('testing')->setNamespace('collections');
+        $db->create();
+
+        $meta = $db->getCollection(Database::METADATA);
+        $attributes = $meta->attributes;
+
+        $keys = [];
+        foreach ($attributes as $attribute) {
+            $keys[] = $this->fields($attribute)['key'];
+        }
+
+        $this->assertNotContains('externalId', $keys);
+    }
+
+    /**
+     * @param  array<string, mixed>  $definition
+     * @return array{0: array<string, mixed>, 1: list<mixed>}
+     */
+    private function resolve(array $definition): array
+    {
+        $attributes = $definition['attributes'] ?? [];
+        if (! \is_array($attributes)) {
+            $attributes = [];
+        }
+
+        return [$definition, \array_values($attributes)];
+    }
+
+    /**
+     * @return array{key: string, type: string, size: int, required: bool, filters: array<int, string>}
+     */
+    private function fields(mixed $attribute): array
+    {
+        if ($attribute instanceof Attribute) {
+            $key = $attribute->key;
+            $type = $attribute->type->value;
+            $size = $attribute->size;
+            $required = $attribute->required;
+            $filters = $attribute->filters;
+        } elseif ($attribute instanceof Document) {
+            $key = $attribute->getAttribute('key', $attribute->getId());
+            $type = $attribute->getAttribute('type', '');
+            $size = $attribute->getAttribute('size', 0);
+            $required = $attribute->getAttribute('required', false);
+            $filters = $attribute->getAttribute('filters', []);
+        } elseif (\is_array($attribute)) {
+            $key = $attribute['key'] ?? $attribute[Document::ID] ?? '';
+            $type = $attribute['type'] ?? '';
+            $size = $attribute['size'] ?? 0;
+            $required = $attribute['required'] ?? false;
+            $filters = $attribute['filters'] ?? [];
+        } else {
+            $this->fail('Attribute must be a Document or array');
+        }
+
+        if ($type instanceof \BackedEnum) {
+            $type = (string) $type->value;
+        }
+
+        $this->assertIsString($key);
+        $this->assertIsString($type);
+        $this->assertIsInt($size);
+        $this->assertIsBool($required);
+        $this->assertIsArray($filters);
+
+        $typedFilters = [];
+        foreach ($filters as $filter) {
+            $this->assertIsString($filter);
+            $typedFilters[] = $filter;
+        }
+
+        return [
+            'key' => $key,
+            'type' => $type,
+            'size' => $size,
+            'required' => $required,
+            'filters' => $typedFilters,
+        ];
+    }
+}
diff --git a/tests/unit/CollectionModelTest.php b/tests/unit/CollectionModelTest.php
new file mode 100644
index 0000000000..cf01a84505
--- /dev/null
+++ b/tests/unit/CollectionModelTest.php
@@ -0,0 +1,288 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+use Utopia\Database\Attribute\Boolean;
+use Utopia\Database\Attribute\Integer;
+use Utopia\Database\Attribute\StringType;
+use Utopia\Database\Collection;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Query\Schema\Order;
+
+class CollectionModelTest extends TestCase
+{
+    public function testConstructorDefaults(): void
+    {
+        $collection = new Collection();
+
+        $this->assertSame('', $collection->id);
+        $this->assertSame('', $collection->name);
+        $this->assertTrue($collection->isEmpty());
+        $this->assertSame([], $collection->attributes);
+        $this->assertSame([], $collection->indexes);
+        $this->assertNull($collection->permissions);
+        $this->assertTrue($collection->documentSecurity);
+        $this->assertSame([], $collection->metadata);
+    }
+
+    public function testConstructorRequiresAttributeAndIndexModels(): void
+    {
+        $collection = new Collection(
+            id: 'nested',
+            attributes: [
+                Attribute::string(key: 'name', size: 64, required: true),
+            ],
+            indexes: [
+                Index::key(key: 'idx_name', attributes: ['name'], lengths: [64], orders: [Order::Asc]),
+            ],
+        );
+
+        $this->assertSame('name', $collection->attributes[0]->key);
+        $this->assertSame('idx_name', $collection->indexes[0]->key);
+    }
+
+    public function testConstructorWithValues(): void
+    {
+        $attr = Attribute::string(key: 'title', size: 128);
+        $idx = Index::key(key: 'idx_title', attributes: ['title']);
+
+        $collection = new Collection(
+            id: 'users',
+            name: 'Users',
+            attributes: [$attr],
+            indexes: [$idx],
+            permissions: [Permission::read(Role::any())],
+            documentSecurity: false,
+        );
+
+        $this->assertSame('users', $collection->id);
+        $this->assertFalse($collection->isEmpty());
+        $this->assertSame('Users', $collection->name);
+        $this->assertCount(1, $collection->attributes);
+        $this->assertCount(1, $collection->indexes);
+        $this->assertNotNull($collection->permissions);
+        $this->assertCount(1, $collection->permissions);
+        $this->assertFalse($collection->documentSecurity);
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $attr = Attribute::string(key: 'email', size: 256, required: true);
+        $idx = Index::unique(key: 'idx_email', attributes: ['email']);
+
+        $collection = new Collection(
+            id: 'accounts',
+            name: 'Accounts',
+            attributes: [$attr],
+            indexes: [$idx],
+            permissions: [Permission::read(Role::any()), Permission::create(Role::user('admin'))],
+            documentSecurity: true,
+        );
+
+        $doc = $collection;
+
+        $this->assertSame('accounts', $doc->getId());
+        $this->assertSame('Accounts', $doc->getAttribute('name'));
+        $this->assertTrue($doc->getAttribute('documentSecurity'));
+        $this->assertCount(1, $doc->attributes);
+        $this->assertCount(1, $doc->indexes);
+        $this->assertCount(2, $doc->getPermissions());
+    }
+
+    public function testToDocumentUsesIdWhenNameEmpty(): void
+    {
+        $collection = new Collection(id: 'myCol', name: '');
+
+        $this->assertSame('myCol', $collection->getAttribute('name'));
+    }
+
+    public function testToDocumentPreservesNameWhenSet(): void
+    {
+        $collection = new Collection(id: 'myCol', name: 'My Collection');
+
+        $this->assertSame('My Collection', $collection->getAttribute('name'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $attr = Attribute::string(key: 'status', size: 32, required: false, default: 'active');
+        $idx = Index::key(key: 'idx_status', attributes: ['status']);
+
+        $original = new Collection(
+            id: 'projects',
+            name: 'Projects',
+            attributes: [$attr],
+            indexes: [$idx],
+            permissions: [Permission::read(Role::any())],
+            documentSecurity: false,
+        );
+
+        $restored = Collection::fromArray($original->getArrayCopy());
+
+        $this->assertSame($original->id, $restored->id);
+        $this->assertSame($original->name, $restored->name);
+        $this->assertSame($original->documentSecurity, $restored->documentSecurity);
+        $this->assertCount(count($original->attributes), $restored->attributes);
+        $this->assertCount(count($original->indexes), $restored->indexes);
+        $this->assertSame($original->attributes[0]->key, $restored->attributes[0]->key);
+        $this->assertSame($original->indexes[0]->key, $restored->indexes[0]->key);
+        $this->assertInstanceOf(StringType::class, $restored->attributes[0]);
+    }
+
+    public function testFromArrayWithEmptyPayload(): void
+    {
+        $collection = Collection::fromArray([]);
+
+        $this->assertSame('', $collection->id);
+        $this->assertSame('', $collection->name);
+        $this->assertSame([], $collection->attributes);
+        $this->assertSame([], $collection->indexes);
+        $this->assertNull($collection->permissions);
+        $this->assertTrue($collection->documentSecurity);
+    }
+
+    public function testWithMultipleAttributes(): void
+    {
+        $attrs = [
+            Attribute::string(key: 'name', size: 128, required: true),
+            Attribute::string(key: 'email', size: 256, required: true),
+            new Integer(key: 'age', required: false, default: 0),
+            new Boolean(key: 'active'),
+        ];
+
+        $collection = new Collection(id: 'users', attributes: $attrs);
+
+        $this->assertCount(4, $collection->attributes);
+
+        $restored = Collection::fromArray($collection->getArrayCopy());
+        $this->assertCount(4, $restored->attributes);
+        $this->assertSame('name', $restored->attributes[0]->key);
+        $this->assertSame('active', $restored->attributes[3]->key);
+        $this->assertInstanceOf(StringType::class, $restored->attributes[0]);
+        $this->assertInstanceOf(StringType::class, $restored->attributes[1]);
+        $this->assertInstanceOf(Integer::class, $restored->attributes[2]);
+        $this->assertInstanceOf(Boolean::class, $restored->attributes[3]);
+    }
+
+    public function testWithMultipleIndexes(): void
+    {
+        $indexes = [
+            Index::key(key: 'idx_name', attributes: ['name']),
+            Index::unique(key: 'idx_email', attributes: ['email']),
+            Index::key(key: 'idx_compound', attributes: ['name', 'email']),
+        ];
+
+        $collection = new Collection(id: 'users', indexes: $indexes);
+
+        $this->assertCount(3, $collection->indexes);
+
+        $restored = Collection::fromArray($collection->getArrayCopy());
+        $this->assertCount(3, $restored->indexes);
+        $this->assertSame('idx_compound', $restored->indexes[2]->key);
+    }
+
+    public function testWithPermissions(): void
+    {
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::user('admin')),
+            Permission::update(Role::team('editors')),
+            Permission::delete(Role::user('owner')),
+        ];
+
+        $collection = new Collection(id: 'posts', permissions: $permissions);
+
+        $this->assertCount(4, $collection->getPermissions());
+        $this->assertContains(Permission::read(Role::any()), $collection->getPermissions());
+    }
+
+    public function testDocumentSecurityTrue(): void
+    {
+        $collection = new Collection(id: 'secure', documentSecurity: true);
+
+        $this->assertTrue($collection->getAttribute('documentSecurity'));
+    }
+
+    public function testDocumentSecurityFalse(): void
+    {
+        $collection = new Collection(id: 'insecure', documentSecurity: false);
+
+        $this->assertFalse($collection->getAttribute('documentSecurity'));
+    }
+
+    public function testFromDocumentPreservesPermissions(): void
+    {
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+        ];
+
+        $collection = Collection::fromArray([
+            '$id' => 'test',
+            '$permissions' => $permissions,
+            'name' => 'test',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $this->assertNotNull($collection->permissions);
+        $this->assertCount(2, $collection->permissions);
+    }
+
+    public function testConstructorHydratesDocumentAttributesWithoutKey(): void
+    {
+        $collection = new Collection(
+            id: 'bucket_1',
+            attributes: [
+                new Document([
+                    '$id' => 'name',
+                    'type' => 'string',
+                    'size' => 128,
+                    'required' => true,
+                    'signed' => true,
+                    'array' => false,
+                    'filters' => [],
+                ]),
+            ],
+            indexes: [
+                new Document([
+                    '$id' => 'idx_name',
+                    'type' => 'key',
+                    'attributes' => ['name'],
+                    'lengths' => [],
+                    'orders' => [],
+                ]),
+            ],
+        );
+
+        $this->assertSame('name', $collection->attributes[0]->key);
+        $this->assertSame('idx_name', $collection->indexes[0]->key);
+    }
+
+    public function testAttributeModelsStayModels(): void
+    {
+        $attr = Attribute::string(key: 'title', size: 64);
+        $collection = new Collection(id: 'articles', attributes: [$attr]);
+
+        $attributes = $collection->attributes;
+
+        $this->assertSame('title', $attributes[0]->key);
+        $this->assertSame('string', $attributes[0]->getAttribute('type'));
+    }
+
+    public function testIndexModelsStayModels(): void
+    {
+        $idx = Index::fullText(key: 'idx_test', attributes: ['body']);
+        $collection = new Collection(id: 'articles', indexes: [$idx]);
+
+        $indexes = $collection->indexes;
+
+        $this->assertSame('idx_test', $indexes[0]->key);
+        $this->assertSame('fulltext', $indexes[0]->getAttribute('type'));
+    }
+}
diff --git a/tests/unit/Collections/CollectionValidationTest.php b/tests/unit/Collections/CollectionValidationTest.php
new file mode 100644
index 0000000000..9789fb4b8d
--- /dev/null
+++ b/tests/unit/Collections/CollectionValidationTest.php
@@ -0,0 +1,520 @@
+<?php
+
+namespace Tests\Unit\Collections;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class CollectionValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createCollection')->willReturn(true);
+        $this->adapter->method('deleteCollection')->willReturn(true);
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    private function setupExistingCollection(string $id): void
+    {
+        $collection = new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => $id,
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $meta = $this->metaCollection();
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($id, $collection, $meta) {
+                if ($col->getId() === Database::METADATA && $docId === $id) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    private function setupEmptyMetadata(): void
+    {
+        $meta = $this->metaCollection();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testCreateCollectionThrowsOnDuplicateId(): void
+    {
+        $this->setupExistingCollection('existing');
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('already exists');
+        $this->database->createCollection(new Collection(id: 'existing'));
+    }
+
+    public function testCreateCollectionValidatesPermissionsFormat(): void
+    {
+        $this->setupEmptyMetadata();
+        $this->database->enableValidation();
+
+        $this->expectException(DatabaseException::class);
+        $this->database->createCollection(new Collection(id: 'newCol', permissions: ['bad-format']));
+    }
+
+    public function testCreateCollectionWithAttributeLimits(): void
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(1);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(100);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $adapter->method('createCollection')->willReturn(true);
+        $adapter->method('deleteCollection')->willReturn(true);
+        $adapter->method('getDocument')->willReturn(new Document());
+
+        $db = new Database($adapter, new Cache(new None()));
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        $attr = new \Utopia\Database\Attribute(
+            key: 'name',
+            type: \Utopia\Query\Schema\ColumnType::String,
+            size: 128,
+            required: false,
+        );
+
+        $this->expectException(LimitException::class);
+        $this->expectExceptionMessage('Attribute limit');
+        $db->createCollection(new Collection(id: 'newCol', attributes: [$attr]));
+    }
+
+    public function testCreateCollectionRejectsPointAttributeOnMemoryWhenValidateIsOn(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $database
+            ->setDatabase('testing')
+            ->setNamespace('collections')
+            ->enableValidation();
+        $database->create();
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Spatial attributes are not supported');
+
+        $database->createCollection(new Collection(id: 'places', attributes: [
+            Attribute::point(key: 'location'),
+        ]));
+    }
+
+    public function testCreateCollectionAllowsJsonAndRequiredDefaultsWhenValidateIsOn(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $database
+            ->setDatabase('testing')
+            ->setNamespace('collections')
+            ->enableValidation();
+        $database->create();
+
+        $collection = $database->createCollection(new Collection(id: 'users', attributes: [
+            Attribute::string(key: 'prefs', size: 65535, default: new \stdClass(), filters: ['json']),
+            Attribute::string(key: 'status', size: 32, required: true, default: 'active'),
+        ]));
+
+        $this->assertSame('users', $collection->getId());
+    }
+
+    public function testCreateCollectionAcceptsCollectionModel(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $database
+            ->setDatabase('testing')
+            ->setNamespace('collections')
+            ->enableValidation();
+        $database->create();
+
+        $collection = $database->createCollection(new Collection(
+            id: 'users',
+            name: 'Users',
+            attributes: [Attribute::string(key: 'name', required: true)],
+        ));
+
+        $this->assertSame('users', $collection->getId());
+        $this->assertSame('Users', $collection->getAttribute('name'));
+
+        /** @var array<int, Document> $attributes */
+        $attributes = $collection->attributes;
+        $this->assertSame(1, \count($attributes));
+        $this->assertSame('name', $attributes[0]->getAttribute('key'));
+        $this->assertSame('string', $attributes[0]->getAttribute('type'));
+    }
+
+    public function testCreateCollectionEmptyPermissionsUsesDefault(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $database
+            ->setDatabase('testing')
+            ->setNamespace('collections')
+            ->enableValidation();
+        $database->create();
+
+        $anon = $database->createCollection(new Collection(id: 'anon'));
+        $control = $database->createCollection(new Collection(id: 'control'));
+        $locked = $database->createCollection(new Collection(id: 'locked', permissions: []));
+
+        $this->assertSame($control->getPermissions(), $anon->getPermissions());
+        $this->assertSame([Permission::create(Role::any())], $anon->getPermissions());
+        $this->assertSame([], $locked->getPermissions());
+    }
+
+    public function testCreateCollectionWithIndexLimits(): void
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(0);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(100);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $adapter->method('createCollection')->willReturn(true);
+        $adapter->method('deleteCollection')->willReturn(true);
+        $adapter->method('getDocument')->willReturn(new Document());
+
+        $db = new Database($adapter, new Cache(new None()));
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        $attr = new \Utopia\Database\Attribute(
+            key: 'name',
+            type: \Utopia\Query\Schema\ColumnType::String,
+            size: 128,
+            required: false,
+        );
+        $index = new \Utopia\Database\Index(
+            key: 'idx_name',
+            type: \Utopia\Query\Schema\IndexType::Key,
+            attributes: ['name'],
+        );
+
+        $this->expectException(LimitException::class);
+        $this->expectExceptionMessage('Index limit');
+        $db->createCollection(new Collection(id: 'newCol', attributes: [$attr], indexes: [$index]));
+    }
+
+    public function testDeleteCollectionThrowsOnNotFound(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Collection not found');
+        $this->database->deleteCollection('nonexistent');
+    }
+
+    public function testUpdateCollectionUpdatesPermissions(): void
+    {
+        $existingCol = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'testCol',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+
+        $metaAttributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+        ];
+        $metaCollection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            'name' => 'collections',
+            'attributes' => $metaAttributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($existingCol, $metaCollection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $existingCol;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $metaCollection;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+
+        $newPermissions = [Permission::read(Role::any()), Permission::create(Role::user('admin'))];
+        $result = $this->database->updateCollection('testCol', $newPermissions, true);
+        $this->assertTrue($result->getAttribute('documentSecurity'));
+    }
+
+    public function testUpdateCollectionUpdatesDocumentSecurity(): void
+    {
+        $existingCol = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'testCol',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+
+        $metaAttributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+        ];
+        $metaCollection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            'name' => 'collections',
+            'attributes' => $metaAttributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($existingCol, $metaCollection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $existingCol;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $metaCollection;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+
+        $result = $this->database->updateCollection('testCol', [Permission::read(Role::any())], true);
+        $this->assertTrue($result->getAttribute('documentSecurity'));
+    }
+
+    public function testUpdateCollectionThrowsOnNotFound(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+        $this->expectException(NotFoundException::class);
+        $this->database->updateCollection('nonexistent', [Permission::read(Role::any())], true);
+    }
+
+    public function testListCollectionsReturnsCollectionDocuments(): void
+    {
+        $col1 = new Document([
+            '$id' => 'col1',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any())],
+            'name' => 'col1',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $metaAttributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+            new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+        ];
+
+        $metaCollection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
+            'name' => 'collections',
+            'attributes' => $metaAttributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($metaCollection) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $metaCollection;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('find')->willReturn([$col1]);
+
+        $result = $this->database->listCollections();
+        $this->assertCount(1, $result);
+        $this->assertSame('col1', $result[0]->getId());
+    }
+
+    public function testGetCollectionReturnsCollectionDocument(): void
+    {
+        $this->setupExistingCollection('myCol');
+
+        $result = $this->database->getCollection('myCol');
+        $this->assertFalse($result->isEmpty());
+        $this->assertSame('myCol', $result->getId());
+    }
+
+    public function testExistsDelegatesToAdapter(): void
+    {
+        $this->adapter->method('getDatabase')->willReturn('testdb');
+        $this->adapter->method('exists')->willReturn(true);
+
+        $result = $this->database->exists('testdb', 'testCol');
+        $this->assertTrue($result);
+    }
+}
diff --git a/tests/unit/CreateCollectionRaceTest.php b/tests/unit/CreateCollectionRaceTest.php
index 6a4393802b..538c9edc7a 100644
--- a/tests/unit/CreateCollectionRaceTest.php
+++ b/tests/unit/CreateCollectionRaceTest.php
@@ -6,6 +6,8 @@
 use Utopia\Cache\Adapter\Memory as CacheMemory;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
@@ -26,12 +28,7 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
         $database->create();
 
         $collection = 'preCommitCreate';
-        $name = new Document([
-            '$id' => ID::custom('name'),
-            'type' => Database::VAR_STRING,
-            'size' => 128,
-            'required' => false,
-        ]);
+        $name = Attribute::string(key: 'name', size: 128);
 
         $adapter->createCollection($collection, [$name], []);
 
@@ -39,7 +36,7 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
             '$id' => $collection,
             '$collection' => Database::METADATA,
             'name' => $collection,
-            'attributes' => [$name],
+            'attributes' => [$name->toDocument()],
             'indexes' => [],
             'documentSecurity' => true,
             '$permissions' => [
@@ -57,10 +54,10 @@ public function testCreateCollectionDoesNotDropUncommittedPeerTable(): void
         ]));
 
         try {
-            $database->createCollection($collection, [$name], permissions: [
+            $database->createCollection(new Collection(id: $collection, attributes: [$name], permissions: [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
-            ]);
+            ]));
             $this->fail('Expected DuplicateException for an existing physical collection');
         } catch (DuplicateException) {
         }
@@ -96,22 +93,17 @@ public function purge(string $key, string $hash = ''): bool
         $database->create();
 
         $collection = 'preCommitCreatePurgeFail';
-        $name = new Document([
-            '$id' => ID::custom('name'),
-            'type' => Database::VAR_STRING,
-            'size' => 128,
-            'required' => false,
-        ]);
+        $name = Attribute::string(key: 'name', size: 128);
 
         $adapter->createCollection($collection, [$name], []);
 
         $cacheAdapter->failPurge = true;
 
         try {
-            $database->createCollection($collection, [$name], permissions: [
+            $database->createCollection(new Collection(id: $collection, attributes: [$name], permissions: [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
-            ]);
+            ]));
             $this->fail('Expected DuplicateException even when cache purge fails');
         } catch (DuplicateException $exception) {
             $this->assertSame('Collection ' . $collection . ' already exists', $exception->getMessage());
diff --git a/tests/unit/CustomDocumentTypeTest.php b/tests/unit/CustomDocumentTypeTest.php
new file mode 100644
index 0000000000..7e1960a87f
--- /dev/null
+++ b/tests/unit/CustomDocumentTypeTest.php
@@ -0,0 +1,320 @@
+<?php
+
+namespace Tests\Unit;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None as NoneAdapter;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class TestUserDocument extends Document
+{
+    public function getEmail(): string
+    {
+        /** @var string $value */
+        $value = $this->getAttribute('email', '');
+
+        return $value;
+    }
+
+    public function getName(): string
+    {
+        /** @var string $value */
+        $value = $this->getAttribute('name', '');
+
+        return $value;
+    }
+
+    public function isActive(): bool
+    {
+        return $this->getAttribute('status') === 'active';
+    }
+}
+
+class TestPostDocument extends Document
+{
+    public function getTitle(): string
+    {
+        /** @var string $value */
+        $value = $this->getAttribute('title', '');
+
+        return $value;
+    }
+
+    public function getContent(): string
+    {
+        /** @var string $value */
+        $value = $this->getAttribute('content', '');
+
+        return $value;
+    }
+}
+
+class CustomDocumentTypeTest extends TestCase
+{
+    private Database $database;
+
+    private Adapter&Stub $adapter;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('1970-01-01 00:00:00'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('2999-12-31 23:59:59'));
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return match ($cap) {
+                Capability::DefinedAttributes => true,
+                default => false,
+            };
+        });
+        $this->adapter->method('withTransaction')->willReturnCallback(
+            fn (callable $callback) => $callback()
+        );
+        $this->adapter->method('getSequences')->willReturnCallback(
+            fn (string $collection, array $documents) => $documents
+        );
+
+        $cache = new Cache(new NoneAdapter());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->disableValidation();
+        $this->database->disableFilters();
+    }
+
+    public function testSetDocumentTypeStoresMapping(): void
+    {
+        $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->assertEquals(TestUserDocument::class, $this->database->getDocumentType('users'));
+    }
+
+    public function testGetDocumentTypeReturnsClass(): void
+    {
+        $this->database->setDocumentType('posts', TestPostDocument::class);
+        $this->assertEquals(TestPostDocument::class, $this->database->getDocumentType('posts'));
+    }
+
+    public function testGetDocumentTypeReturnsNullForUnmapped(): void
+    {
+        $this->assertNull($this->database->getDocumentType('nonexistent'));
+    }
+
+    public function testSetDocumentTypeValidatesClassExists(): void
+    {
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('does not exist');
+
+        $this->database->setDocumentType('users', 'NonExistentClass');
+    }
+
+    public function testSetDocumentTypeValidatesClassExtendsDocument(): void
+    {
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('must extend');
+
+        $this->database->setDocumentType('users', \stdClass::class);
+    }
+
+    public function testClearDocumentTypeRemovesMapping(): void
+    {
+        $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->assertEquals(TestUserDocument::class, $this->database->getDocumentType('users'));
+
+        $this->database->clearDocumentType('users');
+        $this->assertNull($this->database->getDocumentType('users'));
+    }
+
+    public function testClearAllDocumentTypesRemovesAll(): void
+    {
+        $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->database->setDocumentType('posts', TestPostDocument::class);
+
+        $this->assertEquals(TestUserDocument::class, $this->database->getDocumentType('users'));
+        $this->assertEquals(TestPostDocument::class, $this->database->getDocumentType('posts'));
+
+        $this->database->clearAllDocumentTypes();
+
+        $this->assertNull($this->database->getDocumentType('users'));
+        $this->assertNull($this->database->getDocumentType('posts'));
+    }
+
+    public function testMethodChaining(): void
+    {
+        $this->database
+            ->setDocumentType('users', TestUserDocument::class)
+            ->setDocumentType('posts', TestPostDocument::class);
+
+        $this->assertEquals(TestUserDocument::class, $this->database->getDocumentType('users'));
+        $this->assertEquals(TestPostDocument::class, $this->database->getDocumentType('posts'));
+    }
+
+    public function testClearDocumentTypeReturnsSelf(): void
+    {
+        $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->database->clearDocumentType('users');
+        $this->assertNull($this->database->getDocumentType('users'));
+    }
+
+    public function testClearAllDocumentTypesReturnsSelf(): void
+    {
+        $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->database->clearAllDocumentTypes();
+        $this->assertNull($this->database->getDocumentType('users'));
+    }
+
+    public function testCreateDocumentInstanceReturnsCorrectType(): void
+    {
+        $collection = new Document([
+            '$id' => 'users',
+            '$collection' => Database::METADATA,
+            '$permissions' => [
+                Permission::create(Role::any()),
+                Permission::read(Role::any()),
+            ],
+            'name' => 'users',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id) use ($collection) {
+                if ($col->getId() === Database::METADATA && $id === 'users') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->database->setDocumentType('users', TestUserDocument::class);
+
+        $this->database->getAuthorization()->cleanRoles();
+        $this->database->getAuthorization()->addRole('any');
+
+        $result = $this->database->createDocument('users', new Document([
+            '$id' => 'user1',
+            '$permissions' => [],
+            'email' => 'test@example.com',
+            'name' => 'Test User',
+            'status' => 'active',
+        ]));
+
+        $this->assertInstanceOf(TestUserDocument::class, $result);
+        $this->assertEquals('test@example.com', $result->getEmail());
+        $this->assertEquals('Test User', $result->getName());
+        $this->assertTrue($result->isActive());
+    }
+
+    public function testFindResultsUseMappedType(): void
+    {
+        $collection = new Document([
+            '$id' => 'posts',
+            '$collection' => Database::METADATA,
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+            ],
+            'name' => 'posts',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id) use ($collection) {
+                if ($col->getId() === Database::METADATA && $id === 'posts') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('find')->willReturn([
+            new Document([
+                '$id' => 'post1',
+                '$permissions' => [],
+                'title' => 'First Post',
+                'content' => 'Content of first post',
+            ]),
+            new Document([
+                '$id' => 'post2',
+                '$permissions' => [],
+                'title' => 'Second Post',
+                'content' => 'Content of second post',
+            ]),
+        ]);
+
+        $this->database->setDocumentType('posts', TestPostDocument::class);
+
+        $this->database->getAuthorization()->cleanRoles();
+        $this->database->getAuthorization()->addRole('any');
+
+        $results = $this->database->find('posts');
+
+        $this->assertCount(2, $results);
+        $this->assertInstanceOf(TestPostDocument::class, $results[0]);
+        $this->assertInstanceOf(TestPostDocument::class, $results[1]);
+        $this->assertEquals('First Post', $results[0]->getTitle());
+        $this->assertEquals('Second Post', $results[1]->getTitle());
+    }
+
+    public function testUnmappedCollectionReturnsBaseDocument(): void
+    {
+        $collection = new Document([
+            '$id' => 'generic',
+            '$collection' => Database::METADATA,
+            '$permissions' => [
+                Permission::create(Role::any()),
+                Permission::read(Role::any()),
+            ],
+            'name' => 'generic',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $id) use ($collection) {
+                if ($col->getId() === Database::METADATA && $id === 'generic') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $this->adapter->method('createDocument')->willReturnCallback(
+            fn (Document $col, Document $doc) => $doc
+        );
+
+        $this->database->getAuthorization()->cleanRoles();
+        $this->database->getAuthorization()->addRole('any');
+
+        $result = $this->database->createDocument('generic', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [],
+            'data' => 'test',
+        ]));
+
+        $this->assertNotInstanceOf(TestUserDocument::class, $result);
+        $this->assertNotInstanceOf(TestPostDocument::class, $result);
+    }
+}
diff --git a/tests/unit/DateTimeTest.php b/tests/unit/DateTimeTest.php
new file mode 100644
index 0000000000..310eaff2ea
--- /dev/null
+++ b/tests/unit/DateTimeTest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\DateTime;
+
+final class DateTimeTest extends TestCase
+{
+    public function testNowAfterAdvancesAtMillisecondPrecision(): void
+    {
+        $future = '2999-01-01 00:00:00.123';
+
+        $this->assertSame('2999-01-01 00:00:00.124', DateTime::nowAfter($future));
+    }
+
+    public function testNowAfterUsesCurrentTimeForPriorTimestamp(): void
+    {
+        $result = DateTime::nowAfter('2000-01-01 00:00:00.000');
+
+        $this->assertGreaterThan('2000-01-01 00:00:00.000', $result);
+    }
+}
diff --git a/tests/unit/DocumentAdvancedTest.php b/tests/unit/DocumentAdvancedTest.php
new file mode 100644
index 0000000000..893f8def2a
--- /dev/null
+++ b/tests/unit/DocumentAdvancedTest.php
@@ -0,0 +1,448 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\SetType;
+
+class DocumentAdvancedTest extends TestCase
+{
+    public function testDeepCloneWithNestedDocuments(): void
+    {
+        $inner = new Document(['$id' => 'inner', 'value' => 'original']);
+        $middle = new Document(['$id' => 'middle', 'child' => $inner]);
+        $outer = new Document(['$id' => 'outer', 'child' => $middle]);
+
+        $cloned = clone $outer;
+
+        /** @var Document $clonedMiddle */
+        $clonedMiddle = $cloned->getAttribute('child');
+        /** @var Document $clonedInner */
+        $clonedInner = $clonedMiddle->getAttribute('child');
+
+        $clonedInner->setAttribute('value', 'modified');
+
+        $this->assertSame('original', $inner->getAttribute('value'));
+        $this->assertSame('modified', $clonedInner->getAttribute('value'));
+    }
+
+    public function testDeepCloneWithArrayOfDocuments(): void
+    {
+        $doc = new Document([
+            '$id' => 'parent',
+            'items' => [
+                new Document(['$id' => 'a', 'val' => 1]),
+                new Document(['$id' => 'b', 'val' => 2]),
+            ],
+        ]);
+
+        $cloned = clone $doc;
+
+        /** @var array<Document> $clonedItems */
+        $clonedItems = $cloned->getAttribute('items');
+        $clonedItems[0]->setAttribute('val', 99);
+
+        /** @var array<Document> $originalItems */
+        $originalItems = $doc->getAttribute('items');
+        $this->assertSame(1, $originalItems[0]->getAttribute('val'));
+        $this->assertSame(99, $clonedItems[0]->getAttribute('val'));
+    }
+
+    public function testFindWithSubjectKey(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                new Document(['$id' => 'item1', 'name' => 'first']),
+                new Document(['$id' => 'item2', 'name' => 'second']),
+            ],
+        ]);
+
+        $found = $doc->find('name', 'second', 'items');
+        $this->assertInstanceOf(Document::class, $found);
+        $this->assertSame('item2', $found->getId());
+    }
+
+    public function testFindReturnsDocumentOnDirectMatch(): void
+    {
+        $doc = new Document(['$id' => 'test', 'status' => 'active']);
+
+        $result = $doc->find('status', 'active');
+        $this->assertInstanceOf(Document::class, $result);
+        $this->assertSame('test', $result->getId());
+    }
+
+    public function testFindReturnsFalseWhenNotFound(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'items' => [
+                new Document(['$id' => 'a', 'name' => 'alpha']),
+            ],
+        ]);
+
+        $this->assertFalse($doc->find('name', 'nonexistent', 'items'));
+    }
+
+    public function testFindReturnsFalseForDirectMismatch(): void
+    {
+        $doc = new Document(['$id' => 'test', 'status' => 'active']);
+        $this->assertFalse($doc->find('status', 'inactive'));
+    }
+
+    public function testFindAndReplaceWithSubject(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                new Document(['$id' => 'a', 'name' => 'alpha']),
+                new Document(['$id' => 'b', 'name' => 'beta']),
+            ],
+        ]);
+
+        $result = $doc->findAndReplace('name', 'alpha', new Document(['$id' => 'a', 'name' => 'replaced']), 'items');
+        $this->assertTrue($result);
+
+        /** @var array<Document> $items */
+        $items = $doc->getAttribute('items');
+        $this->assertSame('replaced', $items[0]->getAttribute('name'));
+    }
+
+    public function testFindAndReplaceReturnsFalseForMissing(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                new Document(['$id' => 'a', 'name' => 'alpha']),
+            ],
+        ]);
+
+        $this->assertFalse($doc->findAndReplace('name', 'nonexistent', 'new', 'items'));
+    }
+
+    public function testFindAndRemoveWithSubject(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                new Document(['$id' => 'a', 'name' => 'alpha']),
+                new Document(['$id' => 'b', 'name' => 'beta']),
+                new Document(['$id' => 'c', 'name' => 'gamma']),
+            ],
+        ]);
+
+        $result = $doc->findAndRemove('name', 'beta', 'items');
+        $this->assertTrue($result);
+
+        /** @var array<Document> $items */
+        $items = $doc->getAttribute('items');
+        $this->assertCount(2, $items);
+    }
+
+    public function testFindAndRemoveReturnsFalseForMissing(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                new Document(['$id' => 'a', 'name' => 'alpha']),
+            ],
+        ]);
+
+        $this->assertFalse($doc->findAndRemove('name', 'nonexistent', 'items'));
+    }
+
+    public function testGetArrayCopyWithAllowFilter(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'name' => 'John',
+            'email' => 'john@example.com',
+            'age' => 30,
+        ]);
+
+        $copy = $doc->getArrayCopy(['name', 'email']);
+
+        $this->assertArrayHasKey('name', $copy);
+        $this->assertArrayHasKey('email', $copy);
+        $this->assertArrayNotHasKey('$id', $copy);
+        $this->assertArrayNotHasKey('age', $copy);
+    }
+
+    public function testGetArrayCopyWithDisallowFilter(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'name' => 'John',
+            'secret' => 'hidden',
+            'password' => '12345',
+        ]);
+
+        $copy = $doc->getArrayCopy([], ['secret', 'password']);
+
+        $this->assertArrayHasKey('$id', $copy);
+        $this->assertArrayHasKey('name', $copy);
+        $this->assertArrayNotHasKey('secret', $copy);
+        $this->assertArrayNotHasKey('password', $copy);
+    }
+
+    public function testGetArrayCopyWithNestedDocuments(): void
+    {
+        $doc = new Document([
+            '$id' => 'parent',
+            'child' => new Document(['$id' => 'child', 'value' => 'test']),
+        ]);
+
+        $copy = $doc->getArrayCopy();
+        $this->assertIsArray($copy['child']);
+        $this->assertSame('child', $copy['child']['$id']);
+        $this->assertSame('test', $copy['child']['value']);
+    }
+
+    public function testGetArrayCopyWithArrayOfDocuments(): void
+    {
+        $doc = new Document([
+            '$id' => 'parent',
+            'children' => [
+                new Document(['$id' => 'a']),
+                new Document(['$id' => 'b']),
+            ],
+        ]);
+
+        $copy = $doc->getArrayCopy();
+        $children = $copy['children'] ?? null;
+        $this->assertIsArray($children);
+        $this->assertCount(2, $children);
+        $first = $children[0] ?? null;
+        $second = $children[1] ?? null;
+        $this->assertIsArray($first);
+        $this->assertIsArray($second);
+        $this->assertSame('a', $first['$id'] ?? null);
+        $this->assertSame('b', $second['$id'] ?? null);
+    }
+
+    public function testIsEmptyOnDifferentStates(): void
+    {
+        $empty = new Document();
+        $this->assertTrue($empty->isEmpty());
+
+        $withId = new Document(['$id' => 'test']);
+        $this->assertFalse($withId->isEmpty());
+
+        $withAttribute = new Document(['name' => 'test']);
+        $this->assertFalse($withAttribute->isEmpty());
+    }
+
+    public function testGetAttributeWithDefaultValue(): void
+    {
+        $doc = new Document(['$id' => 'test', 'name' => 'John']);
+
+        $this->assertSame('John', $doc->getAttribute('name', 'default'));
+        $this->assertSame('default', $doc->getAttribute('missing', 'default'));
+        $this->assertNull($doc->getAttribute('missing'));
+        $this->assertSame(0, $doc->getAttribute('missing', 0));
+        $this->assertSame([], $doc->getAttribute('missing', []));
+        $this->assertFalse($doc->getAttribute('missing', false));
+    }
+
+    public function testRemoveAttribute(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'name' => 'John',
+            'email' => 'john@example.com',
+        ]);
+
+        $doc->removeAttribute('name');
+
+        $this->assertNull($doc->getAttribute('name'));
+        $this->assertFalse($doc->isSet('name'));
+        $this->assertSame('john@example.com', $doc->getAttribute('email'));
+    }
+
+    public function testRemoveAttributeReturnsSelf(): void
+    {
+        $doc = new Document(['$id' => 'test', 'a' => 1, 'b' => 2]);
+
+        $doc->removeAttribute('a')->removeAttribute('b');
+
+        $this->assertFalse($doc->isSet('a'));
+        $this->assertFalse($doc->isSet('b'));
+    }
+
+    public function testSetAttributesBatch(): void
+    {
+        $doc = new Document(['$id' => 'test']);
+
+        $doc->setAttributes([
+            'name' => 'John',
+            'email' => 'john@example.com',
+            'age' => 25,
+        ]);
+
+        $this->assertSame('John', $doc->getAttribute('name'));
+        $this->assertSame('john@example.com', $doc->getAttribute('email'));
+        $this->assertSame(25, $doc->getAttribute('age'));
+    }
+
+    public function testSetAttributesBatchOverwrites(): void
+    {
+        $doc = new Document(['$id' => 'test', 'name' => 'Old']);
+
+        $doc->setAttributes(['name' => 'New', 'extra' => 'added']);
+
+        $this->assertSame('New', $doc->getAttribute('name'));
+        $this->assertSame('added', $doc->getAttribute('extra'));
+    }
+
+    public function testSetAttributesBatchReturnsSelf(): void
+    {
+        $doc = new Document(['$id' => 'test']);
+        $result = $doc->setAttributes(['a' => 1]);
+
+        $this->assertSame($doc, $result);
+    }
+
+    public function testGetAttributesFiltersInternalKeys(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            '$collection' => 'users',
+            '$permissions' => ['read("any")'],
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            'name' => 'John',
+            'email' => 'john@example.com',
+        ]);
+
+        $attrs = $doc->getAttributes();
+
+        $this->assertArrayHasKey('name', $attrs);
+        $this->assertArrayHasKey('email', $attrs);
+        $this->assertArrayNotHasKey('$id', $attrs);
+        $this->assertArrayNotHasKey('$collection', $attrs);
+        $this->assertArrayNotHasKey('$permissions', $attrs);
+        $this->assertArrayNotHasKey('$createdAt', $attrs);
+        $this->assertArrayNotHasKey('$updatedAt', $attrs);
+    }
+
+    public function testSetTypeAppend(): void
+    {
+        $doc = new Document(['$id' => 'test', 'tags' => ['php']]);
+
+        $doc->setAttribute('tags', 'laravel', SetType::Append);
+
+        $this->assertSame(['php', 'laravel'], $doc->getAttribute('tags'));
+    }
+
+    public function testSetTypeAppendOnNonArray(): void
+    {
+        $doc = new Document(['$id' => 'test', 'value' => 'scalar']);
+
+        $doc->setAttribute('value', 'item', SetType::Append);
+
+        $this->assertSame(['item'], $doc->getAttribute('value'));
+    }
+
+    public function testSetTypeAppendOnMissing(): void
+    {
+        $doc = new Document(['$id' => 'test']);
+
+        $doc->setAttribute('newList', 'first', SetType::Append);
+
+        $this->assertSame(['first'], $doc->getAttribute('newList'));
+    }
+
+    public function testSetTypePrepend(): void
+    {
+        $doc = new Document(['$id' => 'test', 'tags' => ['php']]);
+
+        $doc->setAttribute('tags', 'html', SetType::Prepend);
+
+        $this->assertSame(['html', 'php'], $doc->getAttribute('tags'));
+    }
+
+    public function testSetTypePrependOnNonArray(): void
+    {
+        $doc = new Document(['$id' => 'test', 'value' => 'scalar']);
+
+        $doc->setAttribute('value', 'item', SetType::Prepend);
+
+        $this->assertSame(['item'], $doc->getAttribute('value'));
+    }
+
+    public function testSetTypePrependOnMissing(): void
+    {
+        $doc = new Document(['$id' => 'test']);
+
+        $doc->setAttribute('newList', 'first', SetType::Prepend);
+
+        $this->assertSame(['first'], $doc->getAttribute('newList'));
+    }
+
+    public function testSetTypeAssign(): void
+    {
+        $doc = new Document(['$id' => 'test', 'name' => 'old']);
+
+        $doc->setAttribute('name', 'new', SetType::Assign);
+
+        $this->assertSame('new', $doc->getAttribute('name'));
+    }
+
+    public function testConstructorAutoConvertsNestedArraysToDocuments(): void
+    {
+        $doc = new Document([
+            '$id' => 'parent',
+            'child' => ['$id' => 'child_id', 'name' => 'nested'],
+        ]);
+
+        $child = $doc->getAttribute('child');
+        $this->assertInstanceOf(Document::class, $child);
+        $this->assertSame('child_id', $child->getId());
+    }
+
+    public function testConstructorAutoConvertsArrayOfNestedDocuments(): void
+    {
+        $doc = new Document([
+            '$id' => 'parent',
+            'children' => [
+                ['$id' => 'a', 'name' => 'first'],
+                ['$id' => 'b', 'name' => 'second'],
+            ],
+        ]);
+
+        $children = $doc->getDocuments('children');
+        $this->assertCount(2, $children);
+        $this->assertSame('a', $children[0]->getId());
+        $this->assertSame('b', $children[1]->getId());
+    }
+
+    public function testFindWithArrayValues(): void
+    {
+        $doc = new Document([
+            '$id' => 'root',
+            'items' => [
+                ['name' => 'alpha', 'score' => 1],
+                ['name' => 'beta', 'score' => 2],
+            ],
+        ]);
+
+        $found = $doc->find('name', 'beta', 'items');
+        $this->assertIsArray($found);
+        $this->assertSame('beta', $found['name']);
+        $this->assertSame(2, $found['score']);
+    }
+
+    public function testGetArrayCopyWithEmptyArrayValues(): void
+    {
+        $doc = new Document([
+            '$id' => 'test',
+            'empty_list' => [],
+            'non_empty' => ['a'],
+        ]);
+
+        $copy = $doc->getArrayCopy();
+        $this->assertSame([], $copy['empty_list']);
+        $this->assertSame(['a'], $copy['non_empty']);
+    }
+}
diff --git a/tests/unit/DocumentTest.php b/tests/unit/DocumentTest.php
index 9a41ab5340..e7e451a6e9 100644
--- a/tests/unit/DocumentTest.php
+++ b/tests/unit/DocumentTest.php
@@ -3,44 +3,34 @@
 namespace Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Exception\Structure as StructureException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\PermissionType;
+use Utopia\Database\SetType;
 
 class DocumentTest extends TestCase
 {
-    /**
-     * @var Document
-     */
-    protected ?Document $document = null;
-
-    /**
-     * @var Document
-     */
-    protected ?Document $empty = null;
-
-    /**
-     * @var string
-     */
-    protected ?string $id = null;
-
-    /**
-     * @var string
-     */
-    protected ?string $collection = null;
-
-    public function setUp(): void
+    protected Document $document;
+
+    protected Document $empty;
+
+    protected string $id;
+
+    protected string $collection;
+
+    protected function setUp(): void
     {
         $this->id = uniqid();
 
         $this->collection = uniqid();
 
         $this->document = new Document([
-            '$id' => ID::custom($this->id),
-            '$collection' => ID::custom($this->collection),
-            '$permissions' => [
+            Document::ID => ID::custom($this->id),
+            Document::COLLECTION => ID::custom($this->collection),
+            Document::PERMISSIONS => [
                 Permission::read(Role::user(ID::custom('123'))),
                 Permission::read(Role::team(ID::custom('123'))),
                 Permission::create(Role::any()),
@@ -52,23 +42,23 @@ public function setUp(): void
             ],
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 new Document(['name' => 'x']),
                 new Document(['name' => 'y']),
                 new Document(['name' => 'z']),
-            ]
+            ],
         ]);
 
         $this->empty = new Document();
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testDocumentNulls(): void
+    public function test_document_nulls(): void
     {
         $data = [
             'cat' => null,
@@ -86,58 +76,90 @@ public function testDocumentNulls(): void
         $this->assertEquals('dog', $document->getAttribute('dog', 'dog'));
     }
 
-    public function testId(): void
+    public function test_id(): void
     {
         $this->assertEquals($this->id, $this->document->getId());
         $this->assertEquals(null, $this->empty->getId());
     }
 
-    public function testCollection(): void
+    public function test_non_string_id_throws(): void
+    {
+        $this->expectException(StructureException::class);
+        $this->expectExceptionMessage(Document::ID.' must be of type string');
+
+        new Document([
+            Document::ID => 123,
+        ]);
+    }
+
+    public function testFromRowCoercesNullIdToEmptyString(): void
+    {
+        $document = Document::fromRow([
+            Document::ID => null,
+            'name' => 'unmatched',
+        ]);
+
+        $this->assertSame('', $document->getId());
+        $this->assertSame('unmatched', $document->getAttribute('name'));
+    }
+
+    public function test_id_and_collection_accessors(): void
+    {
+        $document = new Document([
+            Document::ID => 'doc-1',
+            Document::COLLECTION => 'users',
+        ]);
+
+        $this->assertSame('doc-1', $document->getId());
+        $this->assertSame('users', $document->getCollection());
+    }
+
+    public function test_collection(): void
     {
         $this->assertEquals($this->collection, $this->document->getCollection());
         $this->assertEquals(null, $this->empty->getCollection());
     }
 
-    public function testGetCreate(): void
+    public function test_get_create(): void
     {
         $this->assertEquals(['any', 'user:creator'], $this->document->getCreate());
         $this->assertEquals([], $this->empty->getCreate());
     }
 
-    public function testGetRead(): void
+    public function test_get_read(): void
     {
         $this->assertEquals(['user:123', 'team:123'], $this->document->getRead());
         $this->assertEquals([], $this->empty->getRead());
     }
 
-    public function testGetUpdate(): void
+    public function test_get_update(): void
     {
         $this->assertEquals(['any', 'user:updater'], $this->document->getUpdate());
         $this->assertEquals([], $this->empty->getUpdate());
     }
 
-    public function testGetDelete(): void
+    public function test_get_delete(): void
     {
         $this->assertEquals(['any', 'user:deleter'], $this->document->getDelete());
         $this->assertEquals([], $this->empty->getDelete());
     }
 
-    public function testGetPermissionByType(): void
+    public function test_get_permission_by_type(): void
     {
-        $this->assertEquals(['any','user:creator'], $this->document->getPermissionsByType(Database::PERMISSION_CREATE));
-        $this->assertEquals([], $this->empty->getPermissionsByType(Database::PERMISSION_CREATE));
+        $this->assertEquals(['any', 'user:creator'], $this->document->getPermissionsByType(PermissionType::Create));
+        $this->assertEquals([], $this->empty->getPermissionsByType(PermissionType::Create));
 
-        $this->assertEquals(['user:123','team:123'], $this->document->getPermissionsByType(Database::PERMISSION_READ));
-        $this->assertEquals([], $this->empty->getPermissionsByType(Database::PERMISSION_READ));
+        $this->assertEquals(['user:123', 'team:123'], $this->document->getPermissionsByType(PermissionType::Read));
+        $this->assertEquals([], $this->empty->getPermissionsByType(PermissionType::Read));
 
-        $this->assertEquals(['any','user:updater'], $this->document->getPermissionsByType(Database::PERMISSION_UPDATE));
-        $this->assertEquals([], $this->empty->getPermissionsByType(Database::PERMISSION_UPDATE));
+        $this->assertEquals(['any', 'user:updater'], $this->document->getPermissionsByType(PermissionType::Update));
+        $this->assertEquals([], $this->empty->getPermissionsByType(PermissionType::Update));
 
-        $this->assertEquals(['any','user:deleter'], $this->document->getPermissionsByType(Database::PERMISSION_DELETE));
-        $this->assertEquals([], $this->empty->getPermissionsByType(Database::PERMISSION_DELETE));
+        $this->assertEquals(['any', 'user:deleter'], $this->document->getPermissionsByType(PermissionType::Delete));
+        $this->assertEquals([], $this->empty->getPermissionsByType(PermissionType::Delete));
     }
 
-    public function testGetPermissions(): void
+    public function test_get_permissions(): void
     {
         $this->assertEquals([
             Permission::read(Role::user(ID::custom('123'))),
@@ -151,28 +173,28 @@ public function testGetPermissions(): void
         ], $this->document->getPermissions());
     }
 
-    public function testGetAttributes(): void
+    public function test_get_attributes(): void
     {
         $this->assertEquals([
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 new Document(['name' => 'x']),
                 new Document(['name' => 'y']),
                 new Document(['name' => 'z']),
-            ]
+            ],
         ], $this->document->getAttributes());
     }
 
-    public function testGetAttribute(): void
+    public function test_get_attribute(): void
     {
         $this->assertEquals('This is a test.', $this->document->getAttribute('title', ''));
         $this->assertEquals('', $this->document->getAttribute('titlex', ''));
     }
 
-    public function testSetAttribute(): void
+    public function test_set_attribute(): void
     {
         $this->assertEquals('This is a test.', $this->document->getAttribute('title', ''));
         $this->assertEquals(['one'], $this->document->getAttribute('list', []));
@@ -183,17 +205,17 @@ public function testSetAttribute(): void
         $this->assertEquals('New title', $this->document->getAttribute('title', ''));
         $this->assertEquals('', $this->document->getAttribute('titlex', ''));
 
-        $this->document->setAttribute('list', 'two', Document::SET_TYPE_APPEND);
+        $this->document->setAttribute('list', 'two', SetType::Append);
         $this->assertEquals(['one', 'two'], $this->document->getAttribute('list', []));
 
-        $this->document->setAttribute('list', 'zero', Document::SET_TYPE_PREPEND);
+        $this->document->setAttribute('list', 'zero', SetType::Prepend);
         $this->assertEquals(['zero', 'one', 'two'], $this->document->getAttribute('list', []));
 
-        $this->document->setAttribute('list', ['one'], Document::SET_TYPE_ASSIGN);
+        $this->document->setAttribute('list', ['one'], SetType::Assign);
         $this->assertEquals(['one'], $this->document->getAttribute('list', []));
     }
 
-    public function testSetAttributes(): void
+    public function test_set_attributes(): void
     {
         $document = new Document(['$id' => ID::custom(''), '$collection' => 'users']);
 
@@ -217,13 +239,13 @@ public function testSetAttributes(): void
         $this->assertEquals($otherDocument->getAttribute('prefs'), $document->getAttribute('prefs'));
     }
 
-    public function testRemoveAttribute(): void
+    public function test_remove_attribute(): void
     {
         $this->document->removeAttribute('list');
         $this->assertEquals([], $this->document->getAttribute('list', []));
     }
 
-    public function testFind(): void
+    public function test_find(): void
     {
         $this->assertEquals(null, $this->document->find('find', 'one'));
 
@@ -234,16 +256,21 @@ public function testFind(): void
         $this->assertEquals(null, $this->document->find('findArray', 'demo'));
         $this->assertEquals($this->document, $this->document->find('findArray', ['demo']));
 
-        $this->assertEquals($this->document->getAttribute('children')[0], $this->document->find('name', 'x', 'children'));
-        $this->assertEquals($this->document->getAttribute('children')[2], $this->document->find('name', 'z', 'children'));
+        /** @var array<Document> $children */
+        $children = $this->document->getAttribute('children');
+        $this->assertEquals($children[0], $this->document->find('name', 'x', 'children'));
+        $this->assertEquals($children[2], $this->document->find('name', 'z', 'children'));
         $this->assertEquals(null, $this->document->find('name', 'v', 'children'));
     }
 
-    public function testFindAndReplace(): void
+    public function test_find_and_replace(): void
     {
+        $id = $this->id;
+        $collection = $this->collection;
+
         $document = new Document([
-            '$id' => ID::custom($this->id),
-            '$collection' => ID::custom($this->collection),
+            '$id' => ID::custom($id),
+            '$collection' => ID::custom($collection),
             '$permissions' => [
                 Permission::read(Role::user(ID::custom('123'))),
                 Permission::read(Role::team(ID::custom('123'))),
@@ -253,18 +280,20 @@ public function testFindAndReplace(): void
             ],
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 new Document(['name' => 'x']),
                 new Document(['name' => 'y']),
                 new Document(['name' => 'z']),
-            ]
+            ],
         ]);
 
         $this->assertEquals(true, $document->findAndReplace('name', 'x', new Document(['name' => '1', 'test' => true]), 'children'));
-        $this->assertEquals('1', $document->getAttribute('children')[0]['name']);
-        $this->assertEquals(true, $document->getAttribute('children')[0]['test']);
+        /** @var array<array<string, mixed>> $children */
+        $children = $document->getAttribute('children');
+        $this->assertEquals('1', $children[0]['name']);
+        $this->assertEquals(true, $children[0]['test']);
 
         // Array with wrong value
         $this->assertEquals(false, $document->findAndReplace('name', 'xy', new Document(['name' => '1', 'test' => true]), 'children'));
@@ -283,11 +312,14 @@ public function testFindAndReplace(): void
         $this->assertEquals(false, $document->findAndReplace('titlex', 'This is a test.', 'new'));
     }
 
-    public function testFindAndRemove(): void
+    public function test_find_and_remove(): void
     {
+        $id = $this->id;
+        $collection = $this->collection;
+
         $document = new Document([
-            '$id' => ID::custom($this->id),
-            '$collection' => ID::custom($this->collection),
+            '$id' => ID::custom($id),
+            '$collection' => ID::custom($collection),
             '$permissions' => [
                 Permission::read(Role::user(ID::custom('123'))),
                 Permission::read(Role::team(ID::custom('123'))),
@@ -297,17 +329,19 @@ public function testFindAndRemove(): void
             ],
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 new Document(['name' => 'x']),
                 new Document(['name' => 'y']),
                 new Document(['name' => 'z']),
-            ]
+            ],
         ]);
         $this->assertEquals(true, $document->findAndRemove('name', 'x', 'children'));
-        $this->assertEquals('y', $document->getAttribute('children')[1]['name']);
-        $this->assertCount(2, $document->getAttribute('children'));
+        /** @var array<array<string, mixed>> $childrenAfterRemove */
+        $childrenAfterRemove = $document->getAttribute('children');
+        $this->assertEquals('y', $childrenAfterRemove[1]['name']);
+        $this->assertCount(2, $childrenAfterRemove);
 
         // Array with wrong value
         $this->assertEquals(false, $document->findAndRemove('name', 'xy', 'children'));
@@ -326,20 +360,20 @@ public function testFindAndRemove(): void
         $this->assertEquals(false, $document->findAndRemove('titlex', 'This is a test.'));
     }
 
-    public function testIsEmpty(): void
+    public function test_is_empty(): void
     {
         $this->assertEquals(false, $this->document->isEmpty());
         $this->assertEquals(true, $this->empty->isEmpty());
     }
 
-    public function testIsSet(): void
+    public function test_is_set(): void
     {
         $this->assertEquals(false, $this->document->isSet('titlex'));
         $this->assertEquals(false, $this->empty->isSet('titlex'));
         $this->assertEquals(true, $this->document->isSet('title'));
     }
 
-    public function testClone(): void
+    public function test_clone(): void
     {
         $before = new Document([
             'level' => 0,
@@ -358,31 +392,47 @@ public function testClone(): void
                             'children' => [
                                 new Document([
                                     'level' => 3,
-                                    'name' => 'i'
+                                    'name' => 'i',
                                 ]),
-                            ]
-                        ])
-                    ]
-                ])
-            ]
+                            ],
+                        ]),
+                    ],
+                ]),
+            ],
         ]);
 
         $after = clone $before;
 
         $before->setAttribute('name', 'before');
-        $before->getAttribute('document')->setAttribute('name', 'before_one');
-        $before->getAttribute('children')[0]->setAttribute('name', 'before_a');
-        $before->getAttribute('children')[0]->getAttribute('document')->setAttribute('name', 'before_two');
-        $before->getAttribute('children')[0]->getAttribute('children')[0]->setAttribute('name', 'before_x');
+        /** @var Document $beforeDoc */
+        $beforeDoc = $before->getAttribute('document');
+        $beforeDoc->setAttribute('name', 'before_one');
+        /** @var array<Document> $beforeChildren */
+        $beforeChildren = $before->getAttribute('children');
+        $beforeChildren[0]->setAttribute('name', 'before_a');
+        /** @var Document $beforeChildDoc */
+        $beforeChildDoc = $beforeChildren[0]->getAttribute('document');
+        $beforeChildDoc->setAttribute('name', 'before_two');
+        /** @var array<Document> $beforeChildChildren */
+        $beforeChildChildren = $beforeChildren[0]->getAttribute('children');
+        $beforeChildChildren[0]->setAttribute('name', 'before_x');
 
         $this->assertEquals('_', $after->getAttribute('name'));
-        $this->assertEquals('zero', $after->getAttribute('document')->getAttribute('name'));
-        $this->assertEquals('a', $after->getAttribute('children')[0]->getAttribute('name'));
-        $this->assertEquals('one', $after->getAttribute('children')[0]->getAttribute('document')->getAttribute('name'));
-        $this->assertEquals('x', $after->getAttribute('children')[0]->getAttribute('children')[0]->getAttribute('name'));
+        /** @var Document $afterDoc */
+        $afterDoc = $after->getAttribute('document');
+        $this->assertEquals('zero', $afterDoc->getAttribute('name'));
+        /** @var array<Document> $afterChildren */
+        $afterChildren = $after->getAttribute('children');
+        $this->assertEquals('a', $afterChildren[0]->getAttribute('name'));
+        /** @var Document $afterChildDoc */
+        $afterChildDoc = $afterChildren[0]->getAttribute('document');
+        $this->assertEquals('one', $afterChildDoc->getAttribute('name'));
+        /** @var array<Document> $afterChildChildren */
+        $afterChildChildren = $afterChildren[0]->getAttribute('children');
+        $this->assertEquals('x', $afterChildChildren[0]->getAttribute('name'));
     }
 
-    public function testGetArrayCopy(): void
+    public function test_get_array_copy(): void
     {
         $this->assertEquals([
             '$id' => ID::custom($this->id),
@@ -399,18 +449,18 @@ public function testGetArrayCopy(): void
             ],
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 ['name' => 'x'],
                 ['name' => 'y'],
                 ['name' => 'z'],
-            ]
+            ],
         ], $this->document->getArrayCopy());
         $this->assertEquals([], $this->empty->getArrayCopy());
     }
 
-    public function testEmptyDocumentSequence(): void
+    public function test_empty_document_sequence(): void
     {
         $empty = new Document();
 
diff --git a/tests/unit/Documents/AggregationErrorTest.php b/tests/unit/Documents/AggregationErrorTest.php
new file mode 100644
index 0000000000..2347a63c6f
--- /dev/null
+++ b/tests/unit/Documents/AggregationErrorTest.php
@@ -0,0 +1,190 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+
+class AggregationErrorTest extends TestCase
+{
+    /**
+     * @param  array<int, Capability>  $capabilities
+     */
+    private function buildDatabase(array $capabilities): Database
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) use ($capabilities) {
+            return in_array($cap, $capabilities);
+        });
+
+        $collection = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
+            'name' => 'testCol',
+            'attributes' => [
+                new Document(['$id' => 'amount', 'key' => 'amount', 'type' => 'double', 'size' => 0, 'required' => false, 'array' => false]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $adapter->method('find')->willReturn([]);
+        $adapter->method('count')->willReturn(0);
+        $adapter->method('sum')->willReturn(0);
+
+        $cache = new Cache(new None());
+        $db = new Database($adapter, $cache);
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        return $db;
+    }
+
+    public function testFindWithAggregationOnUnsupportedAdapterThrows(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Aggregation queries are not supported');
+        $db->skipValidation(fn () => $db->find('testCol', [Query::count('*', 'cnt')]));
+    }
+
+    public function testFindWithAggregationSkipsRelationshipPopulation(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+            Capability::Aggregations,
+        ]);
+
+        $results = $db->skipValidation(fn () => $db->find('testCol', [Query::count('*', 'cnt')]));
+        $this->assertSame([], $results);
+    }
+
+    public function testFindWithCursorAndAggregationThrows(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+            Capability::Aggregations,
+        ]);
+
+        $cursorDoc = new Document([
+            '$id' => 'c1',
+            '$collection' => 'testCol',
+            '$sequence' => '100',
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Cursor pagination is not supported with aggregation');
+        $db->skipValidation(fn () => $db->find('testCol', [
+            Query::count('*', 'cnt'),
+            Query::cursorAfter($cursorDoc),
+        ]));
+    }
+
+    public function testFindWithJoinOnUnsupportedAdapterThrows(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Join queries are not supported');
+        $db->skipValidation(fn () => $db->find('testCol', [Query::join('other', 'fk', '$id')]));
+    }
+
+    public function testCountWithJoinOnUnsupportedAdapterThrows(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Join queries are not supported');
+        $db->skipValidation(fn () => $db->count('testCol', [Query::join('other', 'fk', '$id')]));
+    }
+
+    public function testSumWithJoinOnUnsupportedAdapterThrows(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Join queries are not supported');
+        $db->skipValidation(fn () => $db->sum('testCol', 'amount', [Query::join('other', 'fk', '$id')]));
+    }
+
+    public function testSumValidatesQueriesWhenEnabled(): void
+    {
+        $db = $this->buildDatabase([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+        ]);
+        $db->enableValidation();
+
+        $this->expectException(QueryException::class);
+        $db->sum('testCol', 'amount', [Query::equal('nonexistent', ['val'])]);
+    }
+}
diff --git a/tests/unit/Documents/ConflictDetectionTest.php b/tests/unit/Documents/ConflictDetectionTest.php
new file mode 100644
index 0000000000..bdb33d987a
--- /dev/null
+++ b/tests/unit/Documents/ConflictDetectionTest.php
@@ -0,0 +1,211 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use DateTime as NativeDateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Conflict as ConflictException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class ConflictDetectionTest extends TestCase
+{
+    private function makeAdapter(): Adapter&Stub
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $adapter->method('updateDocument')->willReturnArgument(2);
+        $adapter->method('deleteDocument')->willReturn(true);
+
+        return $adapter;
+    }
+
+    private function buildDatabase(Adapter&Stub $adapter): Database
+    {
+        $cache = new Cache(new None());
+        $db = new Database($adapter, $cache);
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        return $db;
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     */
+    private function setupCollectionAndDocument(
+        Adapter&Stub $adapter,
+        string $collectionId,
+        Document $existingDoc,
+        array $attributes = [],
+    ): void {
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ];
+
+        $collection = new Document([
+            '$id' => $collectionId,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $collectionId,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collectionId, $collection, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $docId === $collectionId) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+                if ($col->getId() === $collectionId && $docId === $existingDoc->getId()) {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testUpdateDocumentConflictThrows(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-06-15T12:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $requestTime = new NativeDateTime('2024-01-01T00:00:00.000+00:00');
+
+        $this->expectException(ConflictException::class);
+        $this->expectExceptionMessage('Document was updated after the request timestamp');
+
+        $db->withRequestTimestamp($requestTime, function () use ($db) {
+            $db->updateDocument('testCol', 'doc1', new Document([
+                '$id' => 'doc1',
+                '$collection' => 'testCol',
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+                'name' => 'new',
+            ]));
+        });
+    }
+
+    public function testDeleteDocumentConflictThrows(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-06-15T12:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing);
+        $db = $this->buildDatabase($adapter);
+
+        $requestTime = new NativeDateTime('2024-01-01T00:00:00.000+00:00');
+
+        $this->expectException(ConflictException::class);
+        $this->expectExceptionMessage('Document was updated after the request timestamp');
+
+        $db->withRequestTimestamp($requestTime, function () use ($db) {
+            $db->deleteDocument('testCol', 'doc1');
+        });
+    }
+
+    public function testUpdateDocumentNoConflict(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $requestTime = new NativeDateTime('2024-06-15T12:00:00.000+00:00');
+
+        $result = $db->withRequestTimestamp($requestTime, function () use ($db) {
+            return $db->updateDocument('testCol', 'doc1', new Document([
+                '$id' => 'doc1',
+                '$collection' => 'testCol',
+                '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+                'name' => 'new',
+            ]));
+        });
+
+        $this->assertSame('doc1', $result->getId());
+        $this->assertSame(2, $result->getVersion());
+    }
+}
diff --git a/tests/unit/Documents/CreateDocumentLogicTest.php b/tests/unit/Documents/CreateDocumentLogicTest.php
new file mode 100644
index 0000000000..faf7fc0464
--- /dev/null
+++ b/tests/unit/Documents/CreateDocumentLogicTest.php
@@ -0,0 +1,325 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class CreateDocumentLogicTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('createDocuments')->willReturnCallback(function (Document $col, array $docs) {
+            return $docs;
+        });
+        $this->adapter->method('getSequences')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, string>  $permissions
+     */
+    private function setupCollection(string $id, array $attributes = [], array $permissions = []): void
+    {
+        if (empty($permissions)) {
+            $permissions = [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ];
+        }
+
+        $collection = new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($id, $collection) {
+                if ($col->getId() === Database::METADATA && $docId === $id) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testCreateDocumentSetsCreatedAtAndUpdatedAt(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertNotNull($result->getCreatedAt());
+        $this->assertNotNull($result->getUpdatedAt());
+    }
+
+    public function testCreateDocumentSetsVersionTo1(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertSame(1, $result->getVersion());
+    }
+
+    public function testCreateDocumentGeneratesIdIfEmpty(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertNotEmpty($result->getId());
+    }
+
+    public function testCreateDocumentUsesProvidedId(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$id' => 'custom-id',
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertSame('custom-id', $result->getId());
+    }
+
+    public function testCreateDocumentValidatesStructureWhenEnabled(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 128, 'required' => true, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes);
+        $this->database->enableValidation();
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $this->expectException(StructureException::class);
+        $this->database->createDocument('testCol', $doc);
+    }
+
+    public function testCreateDocumentSkipsValidationWhenDisabled(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 128, 'required' => true, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes);
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->skipValidation(fn () => $this->database->createDocument('testCol', $doc));
+        $this->assertNotEmpty($result->getId());
+    }
+
+    public function testCreateDocumentChecksCreatePermission(): void
+    {
+        $collection = new Document([
+            '$id' => 'restricted',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::create(Role::user('admin'))],
+            'name' => 'restricted',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'restricted') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $db = new Database($this->adapter, new Cache(new None()));
+
+        $this->expectException(AuthorizationException::class);
+        $db->createDocument('restricted', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'restricted',
+        ]));
+    }
+
+    public function testCreateDocumentSetsCollectionAttribute(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertSame('testCol', $result->getAttribute('$collection'));
+    }
+
+    public function testCreateDocumentValidatesPermissionsFormat(): void
+    {
+        $this->setupCollection('testCol');
+        $this->database->enableValidation();
+
+        $doc = new Document([
+            '$permissions' => ['invalid-permission-format'],
+            '$collection' => 'testCol',
+        ]);
+
+        $this->expectException(\Utopia\Database\Exception::class);
+        $this->database->createDocument('testCol', $doc);
+    }
+
+    public function testCreateDocumentsSetsTimestampsAndVersion(): void
+    {
+        $this->setupCollection('testCol');
+
+        $docs = [
+            new Document(['$permissions' => [Permission::read(Role::any())], '$collection' => 'testCol']),
+            new Document(['$permissions' => [Permission::read(Role::any())], '$collection' => 'testCol']),
+        ];
+
+        $count = 0;
+        $this->database->createDocuments('testCol', $docs, 100, function (Document $doc) use (&$count) {
+            $count++;
+        });
+
+        $this->assertSame(2, $count);
+    }
+
+    public function testCreateDocumentsCallsOnNextCallbackPerDoc(): void
+    {
+        $this->setupCollection('testCol');
+
+        $docs = [
+            new Document(['$permissions' => [Permission::read(Role::any())], '$collection' => 'testCol']),
+        ];
+
+        $called = false;
+        $this->database->createDocuments('testCol', $docs, 100, function () use (&$called) {
+            $called = true;
+        });
+
+        $this->assertTrue($called);
+    }
+
+    public function testCreateDocumentsCallsOnErrorCallbackOnFailure(): void
+    {
+        $this->setupCollection('testCol');
+
+        $docs = [
+            new Document(['$permissions' => [Permission::read(Role::any())], '$collection' => 'testCol']),
+        ];
+
+        $errorCaught = false;
+        $this->database->createDocuments('testCol', $docs, 100, function () {
+            throw new \RuntimeException('onNext error');
+        }, function (\Throwable $e) use (&$errorCaught) {
+            $errorCaught = true;
+            $this->assertSame('onNext error', $e->getMessage());
+        });
+
+        $this->assertTrue($errorCaught);
+    }
+
+    public function testCreateDocumentsReturnsZeroForEmptyArray(): void
+    {
+        $this->setupCollection('testCol');
+        $count = $this->database->createDocuments('testCol', []);
+        $this->assertSame(0, $count);
+    }
+
+    public function testCreateDocumentSetsEmptyPermissionsWhenNoneProvided(): void
+    {
+        $this->setupCollection('testCol');
+
+        $doc = new Document([
+            '$collection' => 'testCol',
+        ]);
+
+        $result = $this->database->createDocument('testCol', $doc);
+        $this->assertSame([], $result->getPermissions());
+    }
+}
diff --git a/tests/unit/Documents/DocumentCacheEpochTest.php b/tests/unit/Documents/DocumentCacheEpochTest.php
new file mode 100644
index 0000000000..f22935a78f
--- /dev/null
+++ b/tests/unit/Documents/DocumentCacheEpochTest.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\Memory as MemoryCache;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class DocumentCacheEpochTest extends TestCase
+{
+    public function testPurgeCachedCollectionDoesNotThrowWhenEpochPurgeReturnsFalse(): void
+    {
+        [$database, $adapter] = $this->createDatabase();
+        $this->assertTrue($database->purgeCachedCollection('webhooks'));
+
+        [$collectionKey] = $database->getCacheKeys('webhooks');
+        $epochKey = $collectionKey.'#epoch';
+        $before = $database->getCache()->load($epochKey, Database::TTL);
+        $this->assertIsString($before);
+        $this->assertNotSame('', $before);
+
+        $adapter->failPurges();
+
+        $this->assertTrue($database->purgeCachedCollection('webhooks'));
+        $this->assertTrue($database->purgeCachedDocument('webhooks', 'hook'));
+
+        $after = $database->getCache()->load($epochKey, Database::TTL);
+        $this->assertIsString($after);
+        $this->assertNotSame($before, $after);
+    }
+
+    public function testCreateDocumentDoesNotFailWhenEpochPurgeReturnsFalse(): void
+    {
+        [$database, $adapter] = $this->createDatabase();
+        $this->assertTrue($database->purgeCachedCollection('webhooks'));
+        $adapter->failPurges();
+
+        $document = $database->createDocument('webhooks', new Document([
+            '$id' => 'hook',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+            ],
+        ]));
+
+        $this->assertSame('hook', $document->getId());
+        $this->assertSame('hook', $database->getDocument('webhooks', 'hook')->getId());
+    }
+
+    /**
+     * @return array{Database, FailPurgeMemory}
+     */
+    private function createDatabase(): array
+    {
+        $adapter = new FailPurgeMemory();
+        $database = new Database(new DatabaseMemory(), new Cache($adapter));
+        $database
+            ->setDatabase('utopiaTests')
+            ->setNamespace('epoch_'.\uniqid());
+        $database->create();
+        $database->createCollection(new Collection(id: 'webhooks', permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+        ]));
+
+        return [$database, $adapter];
+    }
+}
+
+final class FailPurgeMemory extends MemoryCache
+{
+    private bool $failing = false;
+
+    public function failPurges(): void
+    {
+        $this->failing = true;
+    }
+
+    #[\Override]
+    public function purge(string $key, string $hash = ''): bool
+    {
+        if ($this->failing && \str_ends_with($key, '#epoch')) {
+            return false;
+        }
+
+        return parent::purge($key, $hash);
+    }
+}
diff --git a/tests/unit/Documents/FindLogicTest.php b/tests/unit/Documents/FindLogicTest.php
new file mode 100644
index 0000000000..590da18e69
--- /dev/null
+++ b/tests/unit/Documents/FindLogicTest.php
@@ -0,0 +1,1141 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Order as OrderException;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+
+#[AllowMockObjectsWithoutExpectations]
+class FindLogicTest extends TestCase
+{
+    private Adapter&MockObject $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = $this->createMock(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Vectors,
+            ]);
+        });
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    /**
+     * @param  array<Document>  $attributes
+     * @param  array<Document>  $indexes
+     * @param  array<string>  $permissions
+     */
+    private function collectionDoc(string $id, array $attributes = [], array $indexes = [], array $permissions = [], bool $documentSecurity = true): Document
+    {
+        if (empty($permissions)) {
+            $permissions = [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ];
+        }
+
+        return new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => $documentSecurity,
+        ]);
+    }
+
+    /**
+     * @param  array<Document>  $attributes
+     * @param  array<Document>  $indexes
+     * @param  array<string>  $permissions
+     * @param  array<Document>  $collections
+     */
+    private function setupCollectionLookup(string $id, array $attributes = [], array $indexes = [], array $permissions = [], bool $documentSecurity = true, array $collections = []): void
+    {
+        $map = [$id => $this->collectionDoc($id, $attributes, $indexes, $permissions, $documentSecurity)];
+        foreach ($collections as $collection) {
+            $map[$collection->getId()] = $collection;
+        }
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($map) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+                if ($col->getId() === Database::METADATA && isset($map[$docId])) {
+                    return $map[$docId];
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testFindWithEmptyQueriesReturnsAdapterResults(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $doc = new Document(['$id' => 'doc1', 'name' => 'test']);
+        $this->adapter->method('find')->willReturn([$doc]);
+
+        $results = $this->database->find('testCol');
+        $this->assertCount(1, $results);
+        $this->assertSame('doc1', $results[0]->getId());
+    }
+
+    public function testFindThrowsNotFoundExceptionForMissingCollection(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Collection not found');
+        $this->database->find('nonexistent');
+    }
+
+    public function testFindValidatesQueriesViaDocumentsValidator(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->database->enableValidation();
+        $this->expectException(QueryException::class);
+        $this->database->find('testCol', [Query::equal('nonexistent_attr', ['val'])]);
+    }
+
+    public function testFindRespectsDefaultLimit(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                25,
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol');
+    }
+
+    public function testFindRespectsCustomLimit(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                10,
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::limit(10)]);
+    }
+
+    public function testFindRespectsOffset(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                5,
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::offset(5)]);
+    }
+
+    public function testFindAddsSequenceToOrderByForUniqueness(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function (array $orderAttributes) {
+                    return in_array('$sequence', $orderAttributes, true);
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol');
+    }
+
+    public function testFindSkipsSequenceWhenIdAlreadyInOrder(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function (array $orderAttributes) {
+                    return in_array('$id', $orderAttributes, true)
+                        && ! in_array('$sequence', $orderAttributes, true);
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::orderAsc('$id')]);
+    }
+
+    public function testFindSkipsSequenceWhenSequenceAlreadyInOrder(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function (mixed $orderAttributes): bool {
+                    if (! \is_array($orderAttributes)) {
+                        return false;
+                    }
+                    $values = \array_filter($orderAttributes, \is_string(...));
+                    $sequenceCount = \array_count_values($values)[Document::SEQUENCE] ?? 0;
+
+                    return $sequenceCount === 1;
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::orderAsc('$sequence')]);
+    }
+
+    public function testVectorFindIncludesSequenceTieBreakerWithoutCursor(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'embedding', 'key' => 'embedding', 'type' => ColumnType::Vector->value, 'size' => 2, 'required' => false, 'array' => false]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes);
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                ['$sequence'],
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::vectorCosine('embedding', [0.1, 0.2])]);
+    }
+
+    public function testDateOrderInsertsMatchingSequenceTieBreakSecond(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                ['$createdAt', '$sequence', '$updatedAt'],
+                [OrderDirection::Desc, OrderDirection::Desc, OrderDirection::Asc],
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [
+            Query::orderDesc('$createdAt'),
+            Query::orderAsc('$updatedAt'),
+        ]);
+    }
+
+    public function testFindCursorValidationThrowsOnEmptyCursorAttribute(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false]),
+            new Document(['$id' => 'age', 'key' => 'age', 'type' => 'integer', 'size' => 0, 'required' => false, 'array' => false]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes);
+
+        $cursorDoc = new Document([
+            '$id' => 'cursor1',
+            '$collection' => 'testCol',
+            'name' => 'test',
+        ]);
+
+        $this->expectException(OrderException::class);
+        $this->expectExceptionMessage('Order attribute');
+        $this->database->skipValidation(fn () => $this->database->find('testCol', [
+            Query::orderAsc('name'),
+            Query::orderAsc('age'),
+            Query::cursorAfter($cursorDoc),
+        ]));
+    }
+
+    public function testFindCursorCollectionMismatchThrows(): void
+    {
+        $this->setupCollectionLookup('testCol');
+
+        $cursorDoc = new Document([
+            '$id' => 'cursor1',
+            '$collection' => 'otherCollection',
+            '$sequence' => '1',
+        ]);
+
+        $this->expectException(\Utopia\Database\Exception::class);
+        $this->expectExceptionMessage('cursor Document must be from the same Collection');
+        $this->database->find('testCol', [Query::cursorAfter($cursorDoc)]);
+    }
+
+    public function testFindPassesQueriesToAdapter(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'status', 'key' => 'status', 'type' => 'string', 'size' => 64, 'required' => false, 'array' => false]),
+        ];
+        $indexes = [
+            new Document(['$id' => 'idx_status', 'key' => 'idx_status', 'type' => 'key', 'attributes' => ['status'], 'lengths' => [], 'orders' => []]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes, $indexes);
+
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->callback(function (mixed $queries): bool {
+                    if (! \is_array($queries)) {
+                        return false;
+                    }
+                    foreach ($queries as $q) {
+                        if ($q instanceof Query && $q->getAttribute() === 'status') {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::equal('status', ['active'])]);
+    }
+
+    public function testFindDecodesDocumentsAfterRetrieval(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $rawDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+        ]);
+        $this->adapter->method('find')->willReturn([$rawDoc]);
+
+        $results = $this->database->find('testCol');
+        $this->assertCount(1, $results);
+        $this->assertSame('testCol', $results[0]->getAttribute('$collection'));
+    }
+
+    public function testFindEncodesCursorBeforePassingToAdapter(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $cursorDoc = new Document([
+            '$id' => 'c1',
+            '$collection' => 'testCol',
+            '$sequence' => '100',
+        ]);
+
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function ($cursor) {
+                    return is_array($cursor) && ! empty($cursor);
+                }),
+                CursorDirection::After,
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::cursorAfter($cursorDoc)]);
+    }
+
+    public function testFindWithAggregationOnUnsupportedAdapterThrows(): void
+    {
+        $this->setupCollectionLookup('testCol');
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Aggregation queries are not supported');
+        $this->database->skipValidation(fn () => $this->database->find('testCol', [
+            Query::count('*', 'cnt'),
+        ]));
+    }
+
+    public function testFindWithJoinOnUnsupportedAdapterThrows(): void
+    {
+        $this->setupCollectionLookup('testCol');
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Join queries are not supported');
+        $this->database->skipValidation(fn () => $this->database->find('testCol', [
+            Query::join('other', 'fk', '$id'),
+        ]));
+    }
+
+    public function testFindAggregationWithCursorThrows(): void
+    {
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index, Capability::IndexArray, Capability::UniqueIndex,
+            Capability::DefinedAttributes, Capability::Aggregations,
+        ]);
+
+        $cursorDoc = new Document([
+            '$id' => 'c1',
+            '$collection' => 'testCol',
+            '$sequence' => '100',
+        ]);
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Cursor pagination is not supported with aggregation queries');
+        $db->skipValidation(fn () => $db->find('testCol', [
+            Query::count('*', 'cnt'),
+            Query::cursorAfter($cursorDoc),
+        ]));
+    }
+
+    public function testFindWithGroupBy(): void
+    {
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index, Capability::IndexArray, Capability::UniqueIndex,
+            Capability::DefinedAttributes, Capability::Aggregations,
+        ], function (Adapter&MockObject $adapter): void {
+            $adapter->expects($this->once())
+                ->method('find')
+                ->with(
+                    $this->anything(),
+                    $this->callback(function (mixed $queries): bool {
+                        if (! \is_array($queries)) {
+                            return false;
+                        }
+                        foreach ($queries as $q) {
+                            if ($q instanceof Query && $q->getMethod()->value === 'groupBy') {
+                                return true;
+                            }
+                        }
+
+                        return false;
+                    }),
+                    $this->anything(),
+                    $this->anything(),
+                    $this->anything(),
+                    $this->anything(),
+                    $this->anything(),
+                    $this->anything(),
+                    $this->anything()
+                )
+                ->willReturn([new Document(['status' => 'active', 'cnt' => 5])]);
+        });
+
+        $results = $db->skipValidation(fn () => $db->find('testCol', [
+            Query::groupBy(['status']),
+            Query::count('*', 'cnt'),
+        ]));
+        $this->assertCount(1, $results);
+    }
+
+    public function testFindWithDistinct(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->callback(function (mixed $queries): bool {
+                    if (! \is_array($queries)) {
+                        return false;
+                    }
+                    foreach ($queries as $q) {
+                        if ($q instanceof Query && $q->getMethod()->value === 'distinct') {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->skipValidation(fn () => $this->database->find('testCol', [Query::distinct()]));
+    }
+
+    public function testFindDistinctDoesNotAppendSequenceOrder(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function (array $orderAttributes) {
+                    return ! \in_array(Document::SEQUENCE, $orderAttributes, true);
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->skipValidation(fn () => $this->database->find('testCol', [
+            Query::distinct(),
+        ]));
+    }
+
+    public function testFindSkipsAuthorizationWhenCollectionAllowsRead(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->method('find')->willReturnCallback(function () {
+            $this->assertFalse($this->database->getAuthorization()->getStatus());
+
+            return [];
+        });
+
+        $this->database->skipValidation(fn () => $this->database->find('testCol'));
+    }
+
+    public function testFindKeepsAuthorizationWithoutCollectionRead(): void
+    {
+        $this->setupCollectionLookup('testCol', permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]);
+        $this->adapter->method('find')->willReturnCallback(function () {
+            $this->assertTrue($this->database->getAuthorization()->getStatus());
+
+            return [];
+        });
+
+        $this->database->skipValidation(fn () => $this->database->find('testCol'));
+    }
+
+    public function testFindKeepsAuthorizationEnabledOnJoins(): void
+    {
+        $authOnFind = null;
+        $db = null;
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+            Capability::Joins,
+        ], function (Adapter&MockObject $adapter) use (&$authOnFind, &$db): void {
+            $adapter->method('find')->willReturnCallback(function () use (&$authOnFind, &$db) {
+                $authOnFind = $db?->getAuthorization()->getStatus();
+
+                return [];
+            });
+        }, extraCollections: ['other' => $this->collectionDoc('other')]);
+
+        $db->skipValidation(fn () => $db->find('testCol', [
+            Query::join('other', 'fk', '$id'),
+        ]));
+
+        $this->assertTrue($authOnFind);
+    }
+
+    public function testCountKeepsAuthorizationEnabledOnJoins(): void
+    {
+        $authOnCount = null;
+        $captured = null;
+        $db = null;
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+            Capability::Joins,
+        ], function (Adapter&MockObject $adapter) use (&$authOnCount, &$captured, &$db): void {
+            $adapter->method('count')->willReturnCallback(function (Document $collection, array $queries) use (&$authOnCount, &$captured, &$db) {
+                $authOnCount = $db?->getAuthorization()->getStatus();
+                $captured = $queries;
+
+                return 0;
+            });
+        }, extraCollections: ['other' => $this->collectionDoc('other')]);
+
+        $db->skipValidation(fn () => $db->count('testCol', [
+            Query::join('other', 'fk', '$id'),
+            Query::equal('status', ['ok']),
+        ]));
+
+        $this->assertTrue($authOnCount);
+        $this->assertIsArray($captured);
+        $hasJoin = false;
+        foreach ($captured as $query) {
+            if ($query instanceof Query && $query->getMethod()->isJoin()) {
+                $hasJoin = true;
+                break;
+            }
+        }
+        $this->assertTrue($hasJoin);
+    }
+
+    public function testSumKeepsAuthorizationEnabledOnJoins(): void
+    {
+        $authOnSum = null;
+        $db = null;
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index,
+            Capability::IndexArray,
+            Capability::UniqueIndex,
+            Capability::DefinedAttributes,
+            Capability::Joins,
+        ], function (Adapter&MockObject $adapter) use (&$authOnSum, &$db): void {
+            $adapter->method('sum')->willReturnCallback(function () use (&$authOnSum, &$db) {
+                $authOnSum = $db?->getAuthorization()->getStatus();
+
+                return 0;
+            });
+        }, extraCollections: ['other' => $this->collectionDoc('other')]);
+
+        $db->skipValidation(fn () => $db->sum('testCol', 'status', [
+            Query::join('other', 'fk', '$id'),
+        ]));
+
+        $this->assertTrue($authOnSum);
+    }
+
+    public function testFindStampsJoinDocumentSecurityForPhysicalIds(): void
+    {
+        $captured = null;
+        $join = $this->collectionDoc('jp_public', documentSecurity: false);
+        $db = $this->buildDbWithCapabilities(
+            [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Joins,
+            ],
+            function (Adapter&MockObject $adapter) use (&$captured): void {
+                $adapter->method('find')->willReturnCallback(function (Document $collection) use (&$captured) {
+                    $captured = $collection->getAttribute('joinDocumentSecurity');
+
+                    return [];
+                });
+            },
+            extraCollections: [
+                'database_1_collection_1' => $this->collectionDoc('database_1_collection_1', documentSecurity: false),
+                'database_1_collection_2' => $join,
+            ],
+        );
+
+        $db->skipValidation(fn () => $db->find('database_1_collection_1', [
+            Query::leftJoin('database_1_collection_2', '$id', 'mainId', '=', 'rev'),
+        ]));
+
+        $this->assertIsArray($captured);
+        $this->assertSame(false, $captured['database_1_collection_2'] ?? true);
+        $this->assertSame(false, $captured['jp_public'] ?? true);
+    }
+
+    public function testGetDocumentKeepsAuthorizationEnabledOnJoins(): void
+    {
+        $authOnGet = null;
+        $db = null;
+        $db = $this->buildDbWithCapabilities(
+            [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Joins,
+            ],
+            extraCollections: ['other' => $this->collectionDoc('other')],
+            getDocumentOverride: function (Document $col, string $docId) use (&$authOnGet, &$db): ?Document {
+                if ($col->getId() === Database::METADATA) {
+                    return null;
+                }
+
+                $authOnGet = $db?->getAuthorization()->getStatus();
+
+                return new Document([
+                    '$id' => $docId,
+                    '$collection' => $col->getId(),
+                ]);
+            },
+        );
+
+        $db->skipValidation(fn () => $db->getDocument('testCol', 'doc1', [
+            Query::join('other', 'fk', '$id'),
+        ]));
+
+        $this->assertTrue($authOnGet);
+    }
+
+    public function testFindWithSelectFiltersResults(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false]),
+            new Document(['$id' => 'age', 'key' => 'age', 'type' => 'integer', 'size' => 0, 'required' => false, 'array' => false]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes);
+
+        $rawDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            'name' => 'Alice',
+            'age' => 30,
+        ]);
+        $this->adapter->method('find')->willReturn([$rawDoc]);
+
+        $results = $this->database->find('testCol', [Query::select(['name'])]);
+        $this->assertCount(1, $results);
+    }
+
+    public function testCountDelegatesToAdapter(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->expects($this->once())
+            ->method('count')
+            ->willReturn(42);
+
+        $result = $this->database->count('testCol');
+        $this->assertSame(42, $result);
+    }
+
+    public function testSumDelegatesToAdapter(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'amount', 'key' => 'amount', 'type' => 'double', 'size' => 0, 'required' => false, 'array' => false]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes);
+        $this->adapter->expects($this->once())
+            ->method('sum')
+            ->willReturn(150.5);
+
+        $result = $this->database->sum('testCol', 'amount');
+        $this->assertSame(150.5, $result);
+    }
+
+    public function testCursorYieldsDocumentsFromBatches(): void
+    {
+        $this->setupCollectionLookup('testCol');
+
+        $doc1 = new Document(['$id' => 'd1', '$collection' => 'testCol', '$sequence' => '1']);
+        $doc2 = new Document(['$id' => 'd2', '$collection' => 'testCol', '$sequence' => '2']);
+        $doc3 = new Document(['$id' => 'd3', '$collection' => 'testCol', '$sequence' => '3']);
+
+        $callCount = 0;
+        $this->adapter->method('find')->willReturnCallback(
+            function () use (&$callCount, $doc1, $doc2, $doc3) {
+                $callCount++;
+                if ($callCount === 1) {
+                    return [$doc1, $doc2];
+                }
+                if ($callCount === 2) {
+                    return [$doc3];
+                }
+
+                return [];
+            }
+        );
+
+        $results = [];
+        foreach ($this->database->cursor('testCol', [], 2) as $doc) {
+            $results[] = $doc;
+        }
+        $this->assertCount(3, $results);
+    }
+
+    public function testCursorStopsOnEmptyBatch(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->method('find')->willReturn([]);
+
+        $results = [];
+        foreach ($this->database->cursor('testCol', [], 10) as $doc) {
+            $results[] = $doc;
+        }
+        $this->assertCount(0, $results);
+    }
+
+    public function testCursorStopsWhenBatchSmallerThanBatchSize(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $doc1 = new Document(['$id' => 'd1', '$collection' => 'testCol', '$sequence' => '1']);
+
+        $this->adapter->method('find')->willReturn([$doc1]);
+
+        $results = [];
+        foreach ($this->database->cursor('testCol', [], 5) as $doc) {
+            $results[] = $doc;
+        }
+        $this->assertCount(1, $results);
+    }
+
+    public function testAggregateDelegatesToFind(): void
+    {
+        $db = $this->buildDbWithCapabilities([
+            Capability::Index, Capability::IndexArray, Capability::UniqueIndex,
+            Capability::DefinedAttributes, Capability::Aggregations,
+        ], function (Adapter&MockObject $adapter): void {
+            $aggResult = new Document(['cnt' => 10]);
+            $adapter->expects($this->once())
+                ->method('find')
+                ->willReturn([$aggResult]);
+        });
+
+        /** @var list<Document> $results */
+        $results = $db->skipValidation(fn () => $db->aggregate('testCol', [Query::count('*', 'cnt')]));
+        $this->assertCount(1, $results);
+        $this->assertSame(10, $results[0]->getAttribute('cnt'));
+    }
+
+    public function testFindWithValidationDisabledAllowsUnknownAttributes(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->adapter->method('find')->willReturn([]);
+
+        $results = $this->database->skipValidation(
+            fn () => $this->database->find('testCol', [Query::equal('nonexistent', ['val'])])
+        );
+        $this->assertCount(0, $results);
+    }
+
+    public function testFindAuthorizationCheckWhenNoPermission(): void
+    {
+        $collection = new Document([
+            '$id' => 'restricted',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::user('admin'))],
+            'name' => 'restricted',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => false,
+        ]);
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'restricted') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $db = new Database($this->adapter, new Cache(new None()));
+
+        $this->expectException(AuthorizationException::class);
+        $db->find('restricted');
+    }
+
+    public function testFindAllowsDocumentSecurityWhenCollectionPermissionFails(): void
+    {
+        $collection = new Document([
+            '$id' => 'docSec',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::user('admin'))],
+            'name' => 'docSec',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'docSec') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('find')->willReturn([]);
+
+        $db = new Database($this->adapter, new Cache(new None()));
+        $results = $db->find('docSec');
+        $this->assertCount(0, $results);
+    }
+
+    public function testFindSetsCollectionAttributeOnResults(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $doc = new Document(['$id' => 'doc1']);
+        $this->adapter->method('find')->willReturn([$doc]);
+
+        $results = $this->database->find('testCol');
+        $this->assertSame('testCol', $results[0]->getAttribute('$collection'));
+    }
+
+    public function testFindCursorBeforePassesDirection(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $cursorDoc = new Document([
+            '$id' => 'c1',
+            '$collection' => 'testCol',
+            '$sequence' => '100',
+        ]);
+
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                CursorDirection::Before,
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::cursorBefore($cursorDoc)]);
+    }
+
+    public function testFindMultipleOrderAttributes(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false]),
+            new Document(['$id' => 'age', 'key' => 'age', 'type' => 'integer', 'size' => 0, 'required' => false, 'array' => false]),
+        ];
+        $this->setupCollectionLookup('testCol', $attributes);
+
+        $this->adapter->expects($this->once())
+            ->method('find')
+            ->with(
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->callback(function (array $orderAttributes) {
+                    return $orderAttributes[0] === 'name'
+                        && $orderAttributes[1] === 'age'
+                        && in_array('$sequence', $orderAttributes, true);
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [
+            Query::orderAsc('name'),
+            Query::orderDesc('age'),
+        ]);
+    }
+
+    public function testCountThrowsAuthorizationForMissingCollection(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+        $this->expectException(AuthorizationException::class);
+        $this->database->count('nonexistent');
+    }
+
+    public function testSumThrowsAuthorizationForMissingCollection(): void
+    {
+        $this->adapter->method('getDocument')->willReturn(new Document());
+        $this->expectException(AuthorizationException::class);
+        $this->database->sum('nonexistent', 'amount');
+    }
+
+    public function testSumValidatesQueries(): void
+    {
+        $this->setupCollectionLookup('testCol');
+        $this->database->enableValidation();
+
+        $this->expectException(QueryException::class);
+        $this->database->sum('testCol', 'amount', [Query::equal('unknown_field', ['val'])]);
+    }
+
+    /**
+     * @param  list<Capability>  $capabilities
+     * @param  (callable(Adapter&MockObject): void)|null  $adapterSetup
+     * @param  array<string, Document>  $extraCollections
+     * @param  (callable(Document, string): ?Document)|null  $getDocumentOverride
+     */
+    private function buildDbWithCapabilities(
+        array $capabilities,
+        ?callable $adapterSetup = null,
+        array $extraCollections = [],
+        ?callable $getDocumentOverride = null,
+    ): Database {
+        $adapter = $this->createMock(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) use ($capabilities) {
+            return in_array($cap, $capabilities);
+        });
+
+        $collectionMap = [
+            'testCol' => new Document([
+                '$id' => 'testCol',
+                '$collection' => Database::METADATA,
+                '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
+                'name' => 'testCol',
+                'attributes' => [
+                    new Document(['$id' => 'status', 'key' => 'status', 'type' => 'string', 'size' => 64, 'required' => false, 'array' => false]),
+                ],
+                'indexes' => [],
+                'documentSecurity' => true,
+            ]),
+            ...$extraCollections,
+        ];
+        if ($adapterSetup !== null) {
+            $adapterSetup($adapter);
+        } else {
+            $adapter->method('find')->willReturn([]);
+        }
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collectionMap, $getDocumentOverride) {
+                if ($getDocumentOverride !== null) {
+                    $override = $getDocumentOverride($col, $docId);
+                    if ($override instanceof Document) {
+                        return $override;
+                    }
+                }
+                if ($col->getId() === Database::METADATA && isset($collectionMap[$docId])) {
+                    return $collectionMap[$docId];
+                }
+
+                return new Document();
+            }
+        );
+
+        $cache = new Cache(new None());
+        $db = new Database($adapter, $cache);
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        return $db;
+    }
+}
diff --git a/tests/unit/Documents/IncreaseDecreaseTest.php b/tests/unit/Documents/IncreaseDecreaseTest.php
new file mode 100644
index 0000000000..b8411afa15
--- /dev/null
+++ b/tests/unit/Documents/IncreaseDecreaseTest.php
@@ -0,0 +1,484 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use InvalidArgumentException;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Type as TypeException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Query\Schema\ColumnType;
+
+class IncreaseDecreaseTest extends TestCase
+{
+    private bool $definedAttributes = true;
+
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            if ($cap === Capability::DefinedAttributes) {
+                return $this->definedAttributes;
+            }
+
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::UnsignedBigInt,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('increaseDocumentAttribute')->willReturn(true);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     */
+    private function setupCollectionWithDocument(
+        string $collectionId,
+        Document $existingDoc,
+        array $attributes = [],
+    ): void {
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ];
+
+        $collection = new Document([
+            '$id' => $collectionId,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $collectionId,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collectionId, $collection, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $docId === $collectionId) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+                if ($col->getId() === $collectionId && $docId === $existingDoc->getId()) {
+                    return $existingDoc;
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    private function intAttribute(string $key): Document
+    {
+        return new Document([
+            '$id' => $key,
+            'key' => $key,
+            'type' => ColumnType::Integer->value,
+            'size' => 0,
+            'required' => false,
+            'array' => false,
+            'signed' => true,
+            'filters' => [],
+        ]);
+    }
+
+    private function floatAttribute(string $key): Document
+    {
+        return new Document([
+            '$id' => $key,
+            'key' => $key,
+            'type' => ColumnType::Double->value,
+            'size' => 0,
+            'required' => false,
+            'array' => false,
+            'signed' => true,
+            'filters' => [],
+        ]);
+    }
+
+    private function numericAttribute(string $key, ColumnType|string $type, bool $signed = true): Document
+    {
+        return new Document([
+            '$id' => $key,
+            'key' => $key,
+            'type' => $type instanceof ColumnType ? $type->value : $type,
+            'size' => 0,
+            'required' => false,
+            'array' => false,
+            'signed' => $signed,
+            'filters' => [],
+        ]);
+    }
+
+    public function testIncreaseDocumentAttribute(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $result = $this->database->increaseDocumentAttribute('testCol', 'doc1', 'counter');
+        $this->assertSame(6, $result->getAttribute('counter'));
+    }
+
+    public function testSchemalessIncreaseDefaultsOnlyMissingAttributeToZero(): void
+    {
+        $this->definedAttributes = false;
+        $missing = new Document([
+            '$id' => 'missing',
+            '$collection' => 'testCol',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+        ]);
+        $this->setupCollectionWithDocument('testCol', $missing);
+
+        $result = $this->database->increaseDocumentAttribute('testCol', 'missing', 'counter');
+
+        $this->assertSame(1, $result->getAttribute('counter'));
+    }
+
+    public function testSchemalessIncreaseRejectsExplicitNull(): void
+    {
+        $this->definedAttributes = false;
+        $nullable = new Document([
+            '$id' => 'nullable',
+            '$collection' => 'testCol',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => null,
+        ]);
+        $this->setupCollectionWithDocument('testCol', $nullable);
+
+        $this->expectException(TypeException::class);
+        $this->database->increaseDocumentAttribute('testCol', 'nullable', 'counter');
+    }
+
+    public function testIncreaseDocumentAttributeByCustomValue(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'score' => 10.0,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->floatAttribute('score')]);
+
+        $result = $this->database->increaseDocumentAttribute('testCol', 'doc1', 'score', 2.5);
+        $this->assertSame(12.5, $result->getAttribute('score'));
+    }
+
+    public function testIncreaseAcceptsFloatBigIntegerBigSerialAndLegacyMetadata(): void
+    {
+        $types = [
+            'float' => ColumnType::Float,
+            'biginteger' => ColumnType::BigInteger,
+            'bigserial' => ColumnType::BigSerial,
+            'legacy' => 'bigint',
+        ];
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'float' => 5,
+            'biginteger' => 5,
+            'bigserial' => 5,
+            'legacy' => 5,
+        ]);
+        $attributes = [];
+        foreach ($types as $key => $type) {
+            $attributes[] = $this->numericAttribute($key, $type);
+        }
+        $this->setupCollectionWithDocument('testCol', $doc, $attributes);
+
+        foreach (\array_keys($types) as $key) {
+            $result = $this->database->increaseDocumentAttribute('testCol', 'doc1', $key);
+
+            $this->assertSame(6, $result->getAttribute($key), $key);
+        }
+    }
+
+    public function testIncreaseRejectsBigIntegerOverflow(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => PHP_INT_MAX,
+        ]);
+        $this->setupCollectionWithDocument('testCol', $doc, [
+            $this->numericAttribute('value', ColumnType::BigInteger),
+        ]);
+
+        $this->expectException(LimitException::class);
+        $this->database->increaseDocumentAttribute('testCol', 'doc1', 'value');
+    }
+
+    public function testDecreaseRejectsUnsignedBigIntegerUnderflow(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => 0,
+        ]);
+        $this->setupCollectionWithDocument('testCol', $doc, [
+            $this->numericAttribute('value', ColumnType::BigInteger, false),
+        ]);
+
+        $this->expectException(LimitException::class);
+        $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'value');
+    }
+
+    public function testUnsignedBigIntegerCrossesPhpIntegerBoundaryExactly(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => PHP_INT_MAX,
+        ]);
+        $this->setupCollectionWithDocument('testCol', $doc, [
+            $this->numericAttribute('value', ColumnType::BigInteger, false),
+        ]);
+
+        $increased = $this->database->increaseDocumentAttribute('testCol', 'doc1', 'value');
+        $this->assertSame('9223372036854775808', $increased->getAttribute('value'));
+
+        $decreased = $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'value');
+        $this->assertSame(PHP_INT_MAX, $decreased->getAttribute('value'));
+    }
+
+    public function testUnsignedBigIntegerReachesExactMaximum(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => '18446744073709551614',
+        ]);
+        $this->setupCollectionWithDocument('testCol', $doc, [
+            $this->numericAttribute('value', ColumnType::BigInteger, false),
+        ]);
+
+        $result = $this->database->increaseDocumentAttribute(
+            'testCol',
+            'doc1',
+            'value',
+            1,
+            '18446744073709551615',
+        );
+
+        $this->assertSame('18446744073709551615', $result->getAttribute('value'));
+    }
+
+    public function testUnsignedBigIntegerRejectsOverflowAboveExactMaximum(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'value' => '18446744073709551615',
+        ]);
+        $this->setupCollectionWithDocument('testCol', $doc, [
+            $this->numericAttribute('value', ColumnType::BigInteger, false),
+        ]);
+
+        $this->expectException(LimitException::class);
+        $this->database->increaseDocumentAttribute('testCol', 'doc1', 'value');
+    }
+
+    public function testIncreaseDocumentAttributeWithMax(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 8,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $result = $this->database->increaseDocumentAttribute('testCol', 'doc1', 'counter', 1, 10);
+        $this->assertSame(9, $result->getAttribute('counter'));
+    }
+
+    public function testIncreaseDocumentAttributeExceedsMax(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 10,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->expectException(LimitException::class);
+        $this->database->increaseDocumentAttribute('testCol', 'doc1', 'counter', 1, 10);
+    }
+
+    public function testIncreaseDocumentAttributeWithZeroValue(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Value must be numeric and greater than 0');
+
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->database->increaseDocumentAttribute('testCol', 'doc1', 'counter', 0);
+    }
+
+    public function testIncreaseDocumentAttributeWithNegativeValue(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Value must be numeric and greater than 0');
+
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->database->increaseDocumentAttribute('testCol', 'doc1', 'counter', -1);
+    }
+
+    public function testIncreaseDocumentAttributeNotFound(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->expectException(NotFoundException::class);
+        $this->database->increaseDocumentAttribute('testCol', 'nonexistent', 'counter');
+    }
+
+    public function testDecreaseDocumentAttribute(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 10,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $result = $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'counter');
+        $this->assertSame(9, $result->getAttribute('counter'));
+    }
+
+    public function testDecreaseDocumentAttributeWithMin(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $result = $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'counter', 1, 0);
+        $this->assertSame(4, $result->getAttribute('counter'));
+    }
+
+    public function testDecreaseDocumentAttributeExceedsMin(): void
+    {
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 3,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->expectException(LimitException::class);
+        $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'counter', 5, 0);
+    }
+
+    public function testDecreaseDocumentAttributeWithZeroValue(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Value must be numeric and greater than 0');
+
+        $doc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'counter' => 5,
+        ]);
+
+        $this->setupCollectionWithDocument('testCol', $doc, [$this->intAttribute('counter')]);
+
+        $this->database->decreaseDocumentAttribute('testCol', 'doc1', 'counter', 0);
+    }
+}
diff --git a/tests/unit/Documents/SkipPermissionsTest.php b/tests/unit/Documents/SkipPermissionsTest.php
new file mode 100644
index 0000000000..e4bb2efc80
--- /dev/null
+++ b/tests/unit/Documents/SkipPermissionsTest.php
@@ -0,0 +1,171 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class SkipPermissionsTest extends TestCase
+{
+    private function makeAdapter(): Adapter&Stub
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $adapter->method('createDocument')->willReturnArgument(1);
+        $adapter->method('getSequences')->willReturnArgument(1);
+
+        return $adapter;
+    }
+
+    private function buildDatabase(Adapter&Stub $adapter): Database
+    {
+        $cache = new Cache(new None());
+
+        return new Database($adapter, $cache);
+    }
+
+    public function testGetDocumentWithSkippedPermissions(): void
+    {
+        $adapter = $this->makeAdapter();
+
+        $restrictedDoc = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'secret',
+            '$permissions' => [Permission::read(Role::user('admin'))],
+            'title' => 'Confidential',
+        ]);
+
+        $collection = new Document([
+            '$id' => 'secret',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::user('admin'))],
+            'name' => 'secret',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection, $restrictedDoc) {
+                if ($col->getId() === Database::METADATA && $docId === 'secret') {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+                if ($col->getId() === 'secret' && $docId === 'doc1') {
+                    return $restrictedDoc;
+                }
+
+                return new Document();
+            }
+        );
+
+        $db = $this->buildDatabase($adapter);
+
+        $noPermResult = $db->getDocument('secret', 'doc1');
+        $this->assertTrue($noPermResult->isEmpty());
+
+        $result = $db->getAuthorization()->skip(function () use ($db) {
+            return $db->getDocument('secret', 'doc1');
+        });
+
+        $this->assertFalse($result->isEmpty());
+        $this->assertSame('doc1', $result->getId());
+        $this->assertSame('Confidential', $result->getAttribute('title'));
+    }
+
+    public function testCreateDocumentWithSkippedPermissions(): void
+    {
+        $adapter = $this->makeAdapter();
+
+        $titleAttr = new Document([
+            '$id' => 'title',
+            'key' => 'title',
+            'type' => 'string',
+            'size' => 256,
+            'required' => false,
+            'array' => false,
+            'signed' => true,
+            'filters' => [],
+        ]);
+
+        $collection = new Document([
+            '$id' => 'restricted',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::create(Role::user('admin'))],
+            'name' => 'restricted',
+            'attributes' => [$titleAttr],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'restricted') {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+
+        $db = $this->buildDatabase($adapter);
+
+        $result = $db->getAuthorization()->skip(function () use ($db) {
+            return $db->createDocument('restricted', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                '$collection' => 'restricted',
+                'title' => 'Created via skip',
+            ]));
+        });
+
+        $this->assertNotEmpty($result->getId());
+        $this->assertSame('Created via skip', $result->getAttribute('title'));
+    }
+}
diff --git a/tests/unit/Documents/UpdateDocumentLogicTest.php b/tests/unit/Documents/UpdateDocumentLogicTest.php
new file mode 100644
index 0000000000..7ff8e4d63a
--- /dev/null
+++ b/tests/unit/Documents/UpdateDocumentLogicTest.php
@@ -0,0 +1,401 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+
+class UpdateDocumentLogicTest extends TestCase
+{
+    private function buildDatabase(Adapter&Stub $adapter): Database
+    {
+        $cache = new Cache(new None());
+        $db = new Database($adapter, $cache);
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        return $db;
+    }
+
+    private function makeAdapter(): Adapter&Stub
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $adapter->method('updateDocument')->willReturnArgument(2);
+
+        return $adapter;
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, string>  $collectionPermissions
+     */
+    private function setupCollectionAndDocument(
+        Adapter&Stub $adapter,
+        string $collectionId,
+        Document $existingDoc,
+        array $attributes = [],
+        array $collectionPermissions = []
+    ): void {
+        if (empty($collectionPermissions)) {
+            $collectionPermissions = [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ];
+        }
+
+        $collection = new Document([
+            '$id' => $collectionId,
+            '$collection' => Database::METADATA,
+            '$permissions' => $collectionPermissions,
+            'name' => $collectionId,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collectionId, $collection, $existingDoc) {
+                if ($col->getId() === Database::METADATA && $docId === $collectionId) {
+                    return $collection;
+                }
+                if ($col->getId() === $collectionId && $docId === $existingDoc->getId()) {
+                    return $existingDoc;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    public function testUpdateDocumentSetsUpdatedAt(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $updated = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'new',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $updated);
+        $this->assertNotSame('2024-01-01T00:00:00.000+00:00', $result->getUpdatedAt());
+    }
+
+    public function testUpdateDocumentIncrementsVersion(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 5,
+            'name' => 'old',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $updated = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'new',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $updated);
+        $this->assertSame(6, $result->getVersion());
+    }
+
+    public function testUpdateDocumentChecksUpdatePermission(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'restricted',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::update(Role::user('admin'))],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'restricted', $existing, $attributes, [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::user('admin')),
+        ]);
+
+        $db = new Database($adapter, new Cache(new None()));
+
+        $this->expectException(AuthorizationException::class);
+        $db->updateDocument('restricted', 'doc1', new Document([
+            '$id' => 'doc1',
+            '$collection' => 'restricted',
+            'name' => 'new',
+        ]));
+    }
+
+    public function testUpdateDocumentValidatesStructure(): void
+    {
+        $adapter = $this->makeAdapter();
+        $attributes = [
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 5, 'required' => true, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'title' => 'ok',
+        ]);
+
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+        $db->enableValidation();
+
+        $updated = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'title' => 'this string is way too long for size 5',
+        ]);
+
+        $this->expectException(StructureException::class);
+        $db->updateDocument('testCol', 'doc1', $updated);
+    }
+
+    public function testUpdateDocumentDetectsNoChangesAndPreservesVersion(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 3,
+            'name' => 'same',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $noChange = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'same',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $noChange);
+        $this->assertSame(3, $result->getVersion());
+    }
+
+    public function testUpdateDocumentRequiresId(): void
+    {
+        $adapter = $this->makeAdapter();
+        $adapter->method('getDocument')->willReturn(new Document());
+        $db = $this->buildDatabase($adapter);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Must define $id attribute');
+        $db->updateDocument('testCol', '', new Document([]));
+    }
+
+    public function testUpdateDocumentReturnsEmptyForMissingDocument(): void
+    {
+        $adapter = $this->makeAdapter();
+        $collection = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+            ],
+            'name' => 'testCol',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $collection;
+                }
+
+                return new Document();
+            }
+        );
+
+        $db = $this->buildDatabase($adapter);
+
+        $result = $db->updateDocument('testCol', 'nonexistent', new Document([
+            '$id' => 'nonexistent',
+        ]));
+        $this->assertTrue($result->isEmpty());
+    }
+
+    public function testUpdateDocumentPreservesCreatedAt(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2020-06-15T12:00:00.000+00:00',
+            '$updatedAt' => '2020-06-15T12:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'old',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $updated = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'new',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $updated);
+        $this->assertSame('2020-06-15T12:00:00.000+00:00', $result->getCreatedAt());
+    }
+
+    public function testUpdateDocumentVersionNotIncrementedWhenNoChanges(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 7,
+            'name' => 'unchanged',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $noChange = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'unchanged',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $noChange);
+        $this->assertSame(7, $result->getVersion());
+    }
+
+    public function testUpdateDocumentPermissionChangeIsHandled(): void
+    {
+        $adapter = $this->makeAdapter();
+        $existing = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'same',
+        ]);
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollectionAndDocument($adapter, 'testCol', $existing, $attributes);
+        $db = $this->buildDatabase($adapter);
+
+        $updated = new Document([
+            '$id' => 'doc1',
+            '$collection' => 'testCol',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            'name' => 'same',
+        ]);
+
+        $result = $db->updateDocument('testCol', 'doc1', $updated);
+        $this->assertNotEmpty($result->getId());
+    }
+}
diff --git a/tests/unit/Documents/UpdateDocumentsCastingTest.php b/tests/unit/Documents/UpdateDocumentsCastingTest.php
new file mode 100644
index 0000000000..617c8cb274
--- /dev/null
+++ b/tests/unit/Documents/UpdateDocumentsCastingTest.php
@@ -0,0 +1,98 @@
+<?php
+
+namespace Tests\Unit\Documents;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Operator;
+
+final class UpdateDocumentsCastingTest extends TestCase
+{
+    public function testCastsUpdatesBeforeEveryBatchWrite(): void
+    {
+        $adapter = new class () extends Memory implements Feature\InternalCasting {
+            /** @var array<int, true> */
+            private array $casted = [];
+
+            /** @var array<bool> */
+            public array $receivedCastedUpdates = [];
+
+            /** @var array<int, string> */
+            public array $receivedUpdatedAtTypes = [];
+
+            /** @var array<int, string|null> */
+            public array $receivedUpdatedAtValues = [];
+
+            /** @var array<int, int> */
+            public array $receivedUpdateIds = [];
+
+            public function castingBefore(Document $collection, Document $document): Document
+            {
+                $this->casted[\spl_object_id($document)] = true;
+
+                $value = $document->getAttribute('value');
+                if ($value instanceof Operator) {
+                    $value->setValues([2]);
+                    if ($document->getId() === '') {
+                        $document->setAttribute('$updatedAt', '2000-01-01 00:00:00.000');
+                    }
+                }
+
+                return $document;
+            }
+
+            public function castingAfter(Document $collection, Document $document): Document
+            {
+                return $document;
+            }
+
+            #[\Override]
+            public function updateDocuments(Document $collection, Document $updates, array $documents): int
+            {
+                $this->receivedCastedUpdates[] = isset($this->casted[\spl_object_id($updates)]);
+                $this->receivedUpdatedAtTypes[] = \get_debug_type($updates->getUpdatedAt());
+                $this->receivedUpdatedAtValues[] = $updates->getUpdatedAt();
+                $this->receivedUpdateIds[] = \spl_object_id($updates);
+
+                return parent::updateDocuments($collection, $updates, $documents);
+            }
+        };
+        $database = new Database($adapter, new Cache(new None()));
+        $database->getAuthorization()->disable();
+        $database->setNamespace('casting');
+        $this->assertTrue($database->create());
+        $database->createCollection(new Collection(id: 'counters', attributes: [
+            Attribute::integer(key: 'value'),
+        ]));
+        $database->createDocuments('counters', [
+            new Document(['$id' => 'first', 'value' => 1]),
+            new Document(['$id' => 'second', 'value' => 2]),
+        ]);
+
+        $operator = Operator::increment('1');
+        $modified = $database->updateDocuments(
+            'counters',
+            new Document(['value' => $operator]),
+            batchSize: 1,
+        );
+
+        $this->assertSame(2, $modified);
+        $this->assertSame([true, true], $adapter->receivedCastedUpdates);
+        $this->assertSame(['1'], $operator->getValues());
+        $this->assertSame(['string', 'string'], $adapter->receivedUpdatedAtTypes);
+        $this->assertSame(
+            ['2000-01-01 00:00:00.000', '2000-01-01 00:00:00.000'],
+            $adapter->receivedUpdatedAtValues,
+        );
+        $this->assertCount(1, \array_unique($adapter->receivedUpdateIds));
+        $this->assertSame(3, $database->getDocument('counters', 'first')->getAttribute('value'));
+        $this->assertSame(4, $database->getDocument('counters', 'second')->getAttribute('value'));
+    }
+}
diff --git a/tests/unit/Event/DispatcherHookTest.php b/tests/unit/Event/DispatcherHookTest.php
new file mode 100644
index 0000000000..ef58dfc021
--- /dev/null
+++ b/tests/unit/Event/DispatcherHookTest.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace Tests\Unit\Event;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\DispatcherHook;
+use Utopia\Database\Event\Document\Created as DocumentCreated;
+use Utopia\Database\Event\Document\Deleted as DocumentDeleted;
+use Utopia\Database\Event\Document\Updated as DocumentUpdated;
+
+class DispatcherHookTest extends TestCase
+{
+    private DispatcherHook $hook;
+
+    protected function setUp(): void
+    {
+        $this->hook = new DispatcherHook();
+    }
+
+    public function testDocumentCreatedEvent(): void
+    {
+        $received = null;
+        $this->hook->on(DocumentCreated::class, function (DocumentCreated $event) use (&$received) {
+            $received = $event;
+        });
+
+        $doc = new Document([
+            '$id' => 'doc-1',
+            '$collection' => 'users',
+        ]);
+
+        $this->hook->handle(Event::DocumentCreate, $doc);
+
+        $this->assertInstanceOf(DocumentCreated::class, $received);
+        $this->assertEquals('users', $received->collection);
+        $this->assertSame($doc, $received->document);
+    }
+
+    public function testDocumentUpdatedEvent(): void
+    {
+        $received = null;
+        $this->hook->on(DocumentUpdated::class, function (DocumentUpdated $event) use (&$received) {
+            $received = $event;
+        });
+
+        $doc = new Document([
+            '$id' => 'doc-2',
+            '$collection' => 'posts',
+        ]);
+
+        $this->hook->handle(Event::DocumentUpdate, $doc);
+
+        $this->assertInstanceOf(DocumentUpdated::class, $received);
+        $this->assertEquals('posts', $received->collection);
+    }
+
+    public function testDocumentDeletedEvent(): void
+    {
+        $received = null;
+        $this->hook->on(DocumentDeleted::class, function (DocumentDeleted $event) use (&$received) {
+            $received = $event;
+        });
+
+        $doc = new Document([
+            '$id' => 'doc-3',
+            '$collection' => 'users',
+        ]);
+
+        $this->hook->handle(Event::DocumentDelete, $doc);
+
+        $this->assertInstanceOf(DocumentDeleted::class, $received);
+        $this->assertEquals('doc-3', $received->documentId);
+    }
+
+    public function testUnhandledEventDoesNothing(): void
+    {
+        $called = false;
+        $this->hook->on(DocumentCreated::class, function () use (&$called) {
+            $called = true;
+        });
+
+        $this->hook->handle(Event::DatabaseCreate, 'test');
+
+        $this->assertFalse($called);
+    }
+
+    public function testMultipleListeners(): void
+    {
+        $count = 0;
+        $this->hook->on(DocumentCreated::class, function () use (&$count) {
+            $count++;
+        });
+        $this->hook->on(DocumentCreated::class, function () use (&$count) {
+            $count++;
+        });
+
+        $doc = new Document([
+            '$id' => 'doc-4',
+            '$collection' => 'test',
+        ]);
+
+        $this->hook->handle(Event::DocumentCreate, $doc);
+
+        $this->assertEquals(2, $count);
+    }
+
+    public function testListenerExceptionDoesNotPropagate(): void
+    {
+        $secondCalled = false;
+
+        $this->hook->on(DocumentCreated::class, function () {
+            throw new \RuntimeException('boom');
+        });
+        $this->hook->on(DocumentCreated::class, function () use (&$secondCalled) {
+            $secondCalled = true;
+        });
+
+        $doc = new Document([
+            '$id' => 'doc-5',
+            '$collection' => 'test',
+        ]);
+
+        $this->hook->handle(Event::DocumentCreate, $doc);
+
+        $this->assertTrue($secondCalled);
+    }
+}
diff --git a/tests/unit/Event/DomainTest.php b/tests/unit/Event/DomainTest.php
new file mode 100644
index 0000000000..a2c2d69330
--- /dev/null
+++ b/tests/unit/Event/DomainTest.php
@@ -0,0 +1,130 @@
+<?php
+
+namespace Tests\Unit\Event;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Event\Collection\Created as CollectionCreated;
+use Utopia\Database\Event\Collection\Deleted as CollectionDeleted;
+use Utopia\Database\Event\Document\Created as DocumentCreated;
+use Utopia\Database\Event\Document\Deleted as DocumentDeleted;
+use Utopia\Database\Event\Document\Updated as DocumentUpdated;
+use Utopia\Database\Event\Domain;
+
+class DomainTest extends TestCase
+{
+    public function testDomainEventConstructorWithCollectionAndEvent(): void
+    {
+        $event = new Domain('users', Event::DocumentCreate);
+        $this->assertEquals('users', $event->collection);
+        $this->assertEquals(Event::DocumentCreate, $event->event);
+    }
+
+    public function testDomainEventOccurredAtAutoSetToNow(): void
+    {
+        $before = new \DateTimeImmutable();
+        $event = new Domain('users', Event::DocumentCreate);
+        $after = new \DateTimeImmutable();
+
+        $this->assertGreaterThanOrEqual($before, $event->occurredAt);
+        $this->assertLessThanOrEqual($after, $event->occurredAt);
+    }
+
+    public function testDomainEventCustomOccurredAt(): void
+    {
+        $custom = new \DateTimeImmutable('2025-01-01 12:00:00');
+        $event = new Domain('users', Event::DocumentCreate, $custom);
+        $this->assertSame($custom, $event->occurredAt);
+    }
+
+    public function testDocumentCreatedCarriesDocument(): void
+    {
+        $doc = new Document(['$id' => 'doc1', 'name' => 'Alice']);
+        $event = new DocumentCreated('users', $doc);
+
+        $this->assertSame($doc, $event->document);
+        $this->assertEquals('users', $event->collection);
+    }
+
+    public function testDocumentCreatedHasCorrectEventType(): void
+    {
+        $doc = new Document(['$id' => 'doc1']);
+        $event = new DocumentCreated('users', $doc);
+        $this->assertEquals(Event::DocumentCreate, $event->event);
+    }
+
+    public function testDocumentUpdatedCarriesDocumentAndPrevious(): void
+    {
+        $doc = new Document(['$id' => 'doc1', 'name' => 'Bob']);
+        $prev = new Document(['$id' => 'doc1', 'name' => 'Alice']);
+        $event = new DocumentUpdated('users', $doc, $prev);
+
+        $this->assertSame($doc, $event->document);
+        $this->assertSame($prev, $event->previous);
+        $this->assertEquals(Event::DocumentUpdate, $event->event);
+    }
+
+    public function testDocumentUpdatedWithNullPrevious(): void
+    {
+        $doc = new Document(['$id' => 'doc1']);
+        $event = new DocumentUpdated('users', $doc);
+
+        $this->assertSame($doc, $event->document);
+        $this->assertNull($event->previous);
+    }
+
+    public function testDocumentDeletedCarriesDocumentId(): void
+    {
+        $event = new DocumentDeleted('users', 'doc-42');
+
+        $this->assertEquals('doc-42', $event->documentId);
+        $this->assertEquals('users', $event->collection);
+        $this->assertEquals(Event::DocumentDelete, $event->event);
+    }
+
+    public function testCollectionCreatedCarriesDocument(): void
+    {
+        $doc = new Document(['$id' => 'col1', 'name' => 'users']);
+        $event = new CollectionCreated('users', $doc);
+
+        $this->assertSame($doc, $event->document);
+        $this->assertEquals(Event::CollectionCreate, $event->event);
+    }
+
+    public function testCollectionDeletedHasCorrectEventType(): void
+    {
+        $event = new CollectionDeleted('users');
+        $this->assertEquals(Event::CollectionDelete, $event->event);
+        $this->assertEquals('users', $event->collection);
+    }
+
+    public function testDomainEventIsReadonly(): void
+    {
+        $event = new Domain('users', Event::DocumentCreate);
+
+        $this->assertLessThanOrEqual(new \DateTimeImmutable(), $event->occurredAt);
+        $this->assertEquals('users', $event->collection);
+        $this->assertEquals(Event::DocumentCreate, $event->event);
+    }
+
+    public function testDocumentCreatedOccurredAtIsAutoPopulated(): void
+    {
+        $doc = new Document(['$id' => 'doc1']);
+        $event = new DocumentCreated('users', $doc);
+
+        $this->assertLessThanOrEqual(new \DateTimeImmutable(), $event->occurredAt);
+    }
+
+    public function testDocumentDeletedOccurredAtIsAutoPopulated(): void
+    {
+        $event = new DocumentDeleted('users', 'doc1');
+        $this->assertLessThanOrEqual(new \DateTimeImmutable(), $event->occurredAt);
+    }
+
+    public function testCollectionDeletedOccurredAtIsAutoPopulated(): void
+    {
+        $event = new CollectionDeleted('users');
+        $this->assertLessThanOrEqual(new \DateTimeImmutable(), $event->occurredAt);
+    }
+}
diff --git a/tests/unit/Exception/UniqueTest.php b/tests/unit/Exception/UniqueTest.php
new file mode 100644
index 0000000000..8eafdb34f6
--- /dev/null
+++ b/tests/unit/Exception/UniqueTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit\Exception;
+
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+use Utopia\Database\Exception\Unique;
+
+final class UniqueTest extends TestCase
+{
+    public function testLegacyMessageIsNormalized(): void
+    {
+        $previous = new RuntimeException('previous');
+        $exception = new Unique('Unique index violation', 42, $previous);
+
+        $this->assertSame('Document with the requested unique attributes already exists', $exception->getMessage());
+        $this->assertSame(42, $exception->getCode());
+        $this->assertSame($previous, $exception->getPrevious());
+    }
+
+    public function testSpecificMessageIsPreserved(): void
+    {
+        $exception = new Unique('Custom unique conflict');
+
+        $this->assertSame('Custom unique conflict', $exception->getMessage());
+    }
+}
diff --git a/tests/unit/ForUpdateCacheTest.php b/tests/unit/ForUpdateCacheTest.php
index aef2736b34..7fcd59a2bd 100644
--- a/tests/unit/ForUpdateCacheTest.php
+++ b/tests/unit/ForUpdateCacheTest.php
@@ -6,6 +6,8 @@
 use Utopia\Cache\Adapter\Memory as CacheMemory;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\Permission;
@@ -26,9 +28,9 @@ protected function setUp(): void
             ->setNamespace('for_update_' . \uniqid());
 
         $this->database->create();
-        $this->database->createCollection('projects');
-        $this->database->createAttribute('projects', 'name', Database::VAR_STRING, 255, false);
-        $this->database->createAttribute('projects', 'description', Database::VAR_STRING, 255, false);
+        $this->database->createCollection(new Collection(id: 'projects'));
+        $this->database->createAttribute('projects', Attribute::string(key: 'name'));
+        $this->database->createAttribute('projects', Attribute::string(key: 'description'));
         $this->database->createDocument('projects', new Document([
             '$id' => 'project',
             '$permissions' => [
diff --git a/tests/unit/Format.php b/tests/unit/Format.php
index f4f4a4a0f5..ded6c0bfea 100644
--- a/tests/unit/Format.php
+++ b/tests/unit/Format.php
@@ -8,8 +8,6 @@
  * Format Test for Email
  *
  * Validate that an variable is a valid email address
- *
- * @package Utopia\Validator
  */
 class Format extends Text
 {
@@ -17,8 +15,6 @@ class Format extends Text
      * Get Description
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -30,12 +26,11 @@ public function getDescription(): string
      *
      * Validation will pass when $value is valid email address.
      *
-     * @param  mixed $value
-     * @return bool
+     * @param  mixed  $value
      */
     public function isValid($value): bool
     {
-        if (!\filter_var($value, FILTER_VALIDATE_EMAIL)) {
+        if (! \filter_var($value, FILTER_VALIDATE_EMAIL)) {
             return false;
         }
 
diff --git a/tests/unit/Hook/PermissionAllowNullUidTest.php b/tests/unit/Hook/PermissionAllowNullUidTest.php
new file mode 100644
index 0000000000..a94fad4cf3
--- /dev/null
+++ b/tests/unit/Hook/PermissionAllowNullUidTest.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Tests\Unit\Hook;
+
+use InvalidArgumentException;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Hook\PermissionAllowNullUid;
+use Utopia\Database\Hook\PermissionFilter;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\Condition;
+use Utopia\Query\Hook\Filter;
+
+final class PermissionAllowNullUidTest extends TestCase
+{
+    public function testWrapsPermissionConditionWithNullUid(): void
+    {
+        $inner = new PermissionFilter(
+            roles: ['any'],
+            permissionsTable: static fn (string $table): string => 'perms_'.$table,
+            documentColumn: 'table_main.'.Storage::UID,
+        );
+        $hook = new PermissionAllowNullUid($inner, 'table_main.'.Storage::UID);
+
+        $condition = $hook->filter('movies');
+
+        $this->assertSame(
+            '('.$inner->filter('movies')->expression.' OR `table_main`.`'.Storage::UID.'` IS NULL)',
+            $condition->expression,
+        );
+        $this->assertSame($inner->filter('movies')->bindings, $condition->bindings);
+    }
+
+    public function testQuotesPostgresStyleIdentifiers(): void
+    {
+        $inner = new class () implements Filter {
+            public function filter(string $table): Condition
+            {
+                return new Condition('inner_expr', ['role']);
+            }
+        };
+        $hook = new PermissionAllowNullUid($inner, 'table_main.'.Storage::UID, '"');
+
+        $condition = $hook->filter('movies');
+
+        $this->assertSame('(inner_expr OR "table_main"."'.Storage::UID.'" IS NULL)', $condition->expression);
+        $this->assertSame(['role'], $condition->bindings);
+    }
+
+    public function testRejectsInvalidDocumentColumn(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+
+        new PermissionAllowNullUid(
+            new PermissionFilter(
+                roles: ['any'],
+                permissionsTable: static fn (string $table): string => 'perms_'.$table,
+            ),
+            'table_main._uid; DROP TABLE',
+        );
+    }
+}
diff --git a/tests/unit/Hook/PermissionJoinFilterTest.php b/tests/unit/Hook/PermissionJoinFilterTest.php
new file mode 100644
index 0000000000..ca633edabb
--- /dev/null
+++ b/tests/unit/Hook/PermissionJoinFilterTest.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace Tests\Unit\Hook;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Hook\PermissionFilter;
+use Utopia\Database\Hook\PermissionJoinFilter;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\JoinType;
+use Utopia\Query\Hook\Join\Placement;
+
+final class PermissionJoinFilterTest extends TestCase
+{
+    public function testLeftJoinPlacesPermissionInOnClause(): void
+    {
+        $filter = $this->permissionFilter();
+        $hook = new PermissionJoinFilter($filter, 'j0');
+
+        $result = $hook->filterJoin('j0', JoinType::Left);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::On, $result->placement);
+        $this->assertStringContainsString('j0.'.Storage::UID, $result->condition->expression);
+        $this->assertNull($hook->filterJoin('j1', JoinType::Left));
+    }
+
+    public function testInnerJoinPlacesPermissionInWhereClause(): void
+    {
+        $hook = new PermissionJoinFilter($this->permissionFilter(), 'j0');
+        $result = $hook->filterJoin('j0', JoinType::Inner);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+    }
+
+    public function testRightJoinPlacesPermissionInWhereClause(): void
+    {
+        $hook = new PermissionJoinFilter($this->permissionFilter(), 'j0');
+        $result = $hook->filterJoin('j0', JoinType::Right);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertStringContainsString('j0.'.Storage::UID, $result->condition->expression);
+        $this->assertStringNotContainsString('IS NULL', $result->condition->expression);
+    }
+
+    public function testFullOuterJoinPlacesPermissionInWhereClauseAndAllowsNullUid(): void
+    {
+        $hook = new PermissionJoinFilter($this->permissionFilter(), 'j0');
+        $result = $hook->filterJoin('j0', JoinType::FullOuter);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertStringContainsString('j0.'.Storage::UID, $result->condition->expression);
+        $this->assertStringContainsString('IS NULL', $result->condition->expression);
+        $this->assertSame($this->permissionFilter()->filter('j0')->bindings, $result->condition->bindings);
+    }
+
+    public function testCrossJoinPlacesPermissionInWhereClause(): void
+    {
+        $hook = new PermissionJoinFilter($this->permissionFilter(), 'j0');
+        $result = $hook->filterJoin('j0', JoinType::Cross);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertStringNotContainsString('IS NULL', $result->condition->expression);
+    }
+
+    private function permissionFilter(): PermissionFilter
+    {
+        return new PermissionFilter(
+            roles: ['any'],
+            permissionsTable: static fn (string $table): string => 'perms_'.$table,
+            documentColumn: 'j0.'.Storage::UID,
+        );
+    }
+}
diff --git a/tests/unit/Hook/PermissionsTest.php b/tests/unit/Hook/PermissionsTest.php
new file mode 100644
index 0000000000..b58607a750
--- /dev/null
+++ b/tests/unit/Hook/PermissionsTest.php
@@ -0,0 +1,306 @@
+<?php
+
+namespace Tests\Unit\Hook;
+
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Hook\Permissions;
+use Utopia\Database\PDO;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+
+final class PermissionsTest extends TestCase
+{
+    public function testBatchUpdateParsesEachPermissionTypeOnce(): void
+    {
+        $adapter = $this->adapter();
+
+        $this->assertTrue($adapter->createCollection('movies'));
+        $collection = new Document(['$id' => 'movies']);
+        $documents = $adapter->createDocuments($collection, [
+            new Document(['$id' => 'first', '$permissions' => [Permission::read(Role::any())]]),
+            new Document(['$id' => 'second', '$permissions' => [Permission::read(Role::any())]]),
+        ]);
+        $updates = new class ([
+            '$permissions' => [
+                Permission::read(Role::user('reader')),
+                Permission::update(Role::user('editor')),
+            ],
+        ]) extends Document {
+            public int $calls = 0;
+
+            #[\Override]
+            public function getPermissionsByType(PermissionType $type): array
+            {
+                $this->calls++;
+
+                return parent::getPermissionsByType($type);
+            }
+        };
+
+        $adapter->updateDocuments($collection, $updates, $documents);
+        $this->assertSame(4, $updates->calls);
+    }
+
+    public function testUniqueAdditionsRemovesDuplicateRoles(): void
+    {
+        $additions = $this->invokeHook('uniqueAdditions', [
+            ['any', 'guests', 'guests', 'any'],
+            ['any'],
+        ]);
+
+        $this->assertSame(['guests'], $additions);
+    }
+
+    public function testCurrentPermissionsLookupUsesStoredDocumentIdCase(): void
+    {
+        $stored = [
+            PermissionType::Create->value => ['any'],
+            PermissionType::Read->value => ['any'],
+            PermissionType::Update->value => [],
+            PermissionType::Delete->value => [],
+        ];
+
+        /** @var array<string, list<string>> $current */
+        $current = $this->invokeHook('currentPermissions', [
+            [
+                'caseSensitive' => $stored,
+            ],
+            'CaseSensitive',
+        ]);
+
+        $this->assertSame(['any'], $current[PermissionType::Create->value]);
+        $this->assertSame(['any'], $current[PermissionType::Read->value]);
+    }
+
+    public function testCurrentPermissionsPrefersExactDocumentIdWhenBothCasingsExist(): void
+    {
+        $exact = [
+            PermissionType::Create->value => ['guests'],
+            PermissionType::Read->value => [],
+            PermissionType::Update->value => [],
+            PermissionType::Delete->value => [],
+        ];
+        $other = [
+            PermissionType::Create->value => ['any'],
+            PermissionType::Read->value => [],
+            PermissionType::Update->value => [],
+            PermissionType::Delete->value => [],
+        ];
+
+        /** @var array<string, list<string>> $current */
+        $current = $this->invokeHook('currentPermissions', [
+            [
+                'CaseSensitive' => $exact,
+                'caseSensitive' => $other,
+            ],
+            'CaseSensitive',
+        ]);
+
+        $this->assertSame(['guests'], $current[PermissionType::Create->value]);
+    }
+
+    public function testGroupPermissionRowsMapsStoredDocumentIdToRequestedCasing(): void
+    {
+        /** @var array<string, array<string, list<string>>> $map */
+        $map = $this->invokeHook('groupPermissionRows', [
+            ['CaseSensitive'],
+            [
+                [
+                    Storage::PERM_DOCUMENT => 'caseSensitive',
+                    Storage::PERM_TYPE => PermissionType::Create->value,
+                    Storage::PERM_PERMISSION => 'any',
+                ],
+                [
+                    Storage::PERM_DOCUMENT => 'caseSensitive',
+                    Storage::PERM_TYPE => PermissionType::Read->value,
+                    Storage::PERM_PERMISSION => 'any',
+                ],
+            ],
+        ]);
+
+        $this->assertArrayHasKey('CaseSensitive', $map);
+        $this->assertSame(['any'], $map['CaseSensitive'][PermissionType::Create->value]);
+        $this->assertSame(['any'], $map['CaseSensitive'][PermissionType::Read->value]);
+    }
+
+    public function testGroupPermissionRowsPopulatesBothRequestedCasings(): void
+    {
+        /** @var array<string, array<string, list<string>>> $map */
+        $map = $this->invokeHook('groupPermissionRows', [
+            ['CaseSensitive', 'caseSensitive'],
+            [
+                [
+                    Storage::PERM_DOCUMENT => 'caseSensitive',
+                    Storage::PERM_TYPE => PermissionType::Create->value,
+                    Storage::PERM_PERMISSION => 'any',
+                ],
+            ],
+        ]);
+
+        $this->assertSame(['any'], $map['CaseSensitive'][PermissionType::Create->value]);
+        $this->assertSame(['any'], $map['caseSensitive'][PermissionType::Create->value]);
+    }
+
+    public function testStoredDocumentIdsKeepsTableCasing(): void
+    {
+        /** @var array<string, string> $stored */
+        $stored = $this->invokeHook('storedDocumentIds', [
+            ['CaseSensitive', 'caseSensitive'],
+            [
+                [
+                    Storage::PERM_DOCUMENT => 'caseSensitive',
+                    Storage::PERM_TYPE => PermissionType::Create->value,
+                    Storage::PERM_PERMISSION => 'any',
+                ],
+            ],
+        ]);
+
+        $this->assertSame('caseSensitive', $stored['CaseSensitive']);
+        $this->assertSame('caseSensitive', $stored['caseSensitive']);
+    }
+
+    public function testPermissionDocumentIdUsesStoredCasing(): void
+    {
+        $this->assertSame(
+            'caseSensitive',
+            $this->invokeHook('permissionDocumentId', [
+                'CaseSensitive',
+                ['CaseSensitive' => 'caseSensitive'],
+            ])
+        );
+        $this->assertSame(
+            'new-id',
+            $this->invokeHook('permissionDocumentId', [
+                'new-id',
+                ['old-id' => 'old-id'],
+            ])
+        );
+    }
+
+    public function testUpdateDoesNotInsertDuplicatePermissionRows(): void
+    {
+        $adapter = $this->adapter();
+        $this->assertTrue($adapter->createCollection('movies'));
+        $collection = new Document(['$id' => 'movies']);
+        $adapter->createDocuments($collection, [
+            new Document(['$id' => 'dupes', '$permissions' => [Permission::create(Role::any())]]),
+        ]);
+
+        $update = new class ([
+            '$id' => 'dupes',
+            '$permissions' => [
+                Permission::create(Role::any()),
+                Permission::create(Role::guests()),
+            ],
+        ]) extends Document {
+            #[\Override]
+            public function getPermissionsByType(PermissionType $type): array
+            {
+                if ($type === PermissionType::Create) {
+                    return ['any', 'guests', 'guests'];
+                }
+
+                return parent::getPermissionsByType($type);
+            }
+        };
+
+        $adapter->updateDocument($collection, 'dupes', $update, false);
+
+        $document = $adapter->getDocument($collection, 'dupes');
+        $this->assertSame(['any', 'guests'], $document->getCreate());
+    }
+
+    public function testUpdateDoesNotDuplicatePermissionsWhenDocumentIdCasingDiffers(): void
+    {
+        $adapter = $this->adapter();
+        $this->assertTrue($adapter->createCollection('movies'));
+        $collection = new Document(['$id' => 'movies']);
+        $adapter->createDocuments($collection, [
+            new Document([
+                '$id' => 'caseSensitive',
+                '$permissions' => [
+                    Permission::create(Role::any()),
+                    Permission::read(Role::any()),
+                ],
+            ]),
+        ]);
+
+        $update = new Document([
+            '$id' => 'CaseSensitive',
+            '$permissions' => [
+                Permission::create(Role::any()),
+                Permission::create(Role::guests()),
+                Permission::create(Role::guests()),
+                Permission::read(Role::any()),
+                Permission::read(Role::guests()),
+                Permission::read(Role::guests()),
+            ],
+        ]);
+
+        $adapter->updateDocument($collection, 'caseSensitive', $update, false);
+
+        $document = $adapter->getDocument($collection, 'caseSensitive');
+        $this->assertSame(['any', 'guests'], $document->getCreate());
+        $this->assertSame(['any', 'guests'], $document->getRead());
+    }
+
+    public function testBatchUpdateDeduplicatesPermissionAdditions(): void
+    {
+        $this->expectNotToPerformAssertions();
+
+        $adapter = $this->adapter();
+        $adapter->createCollection('movies');
+        $collection = new Document(['$id' => 'movies']);
+        $documents = $adapter->createDocuments($collection, [
+            new Document(['$id' => 'batch', '$permissions' => [Permission::create(Role::any())]]),
+        ]);
+
+        $updates = new class ([
+            '$permissions' => [
+                Permission::create(Role::any()),
+                Permission::create(Role::guests()),
+            ],
+        ]) extends Document {
+            #[\Override]
+            public function getPermissionsByType(PermissionType $type): array
+            {
+                if ($type === PermissionType::Create) {
+                    return ['any', 'guests', 'guests'];
+                }
+
+                return parent::getPermissionsByType($type);
+            }
+        };
+
+        $adapter->updateDocuments($collection, $updates, $documents);
+    }
+
+    private function adapter(): SQLite
+    {
+        $adapter = new SQLite(new PDO('sqlite::memory:', null, null));
+        $adapter->setNamespace('permissions');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+        $adapter->addWriteHook(new Permissions());
+
+        return $adapter;
+    }
+
+    /**
+     * @param  list<mixed>  $arguments
+     */
+    private function invokeHook(string $method, array $arguments = []): mixed
+    {
+        $hook = new Permissions();
+        $reflection = new ReflectionMethod(Permissions::class, $method);
+
+        return $reflection->invoke($hook, ...$arguments);
+    }
+}
diff --git a/tests/unit/Hook/TenantFilterTest.php b/tests/unit/Hook/TenantFilterTest.php
new file mode 100644
index 0000000000..c4cfc994cf
--- /dev/null
+++ b/tests/unit/Hook/TenantFilterTest.php
@@ -0,0 +1,113 @@
+<?php
+
+namespace Tests\Unit\Hook;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Hook\TenantFilter;
+use Utopia\Database\Storage;
+use Utopia\Query\Builder\JoinType;
+use Utopia\Query\Hook\Join\Placement;
+
+final class TenantFilterTest extends TestCase
+{
+    public function testMetadataPermissionRowsMayBeTenantless(): void
+    {
+        // A shared pool creates its system collections once with no tenant, so
+        // the permission rows for those definitions are tenantless too. Scoping
+        // the side table strictly to the writer's tenant matches neither the
+        // read nor the delete, and revoking a permission on a shared definition
+        // silently does nothing.
+        $hook = new TenantFilter(989, Database::METADATA, Storage::permissionsTable(Database::METADATA));
+
+        $condition = $hook->filter('perms');
+
+        $this->assertStringContainsString('IS NULL', $condition->expression, 'The metadata permissions table must match tenantless rows');
+        $this->assertSame([989], $condition->bindings);
+    }
+
+    public function testANonMetadataPermissionsTableStaysStrictlyTenanted(): void
+    {
+        $hook = new TenantFilter(989, Database::METADATA, Storage::permissionsTable('orders'));
+
+        $condition = $hook->filter('perms');
+
+        $this->assertStringNotContainsString('IS NULL', $condition->expression, 'A project collection must not leak across tenants');
+        $this->assertSame([989], $condition->bindings);
+    }
+
+    public function testFilterDoesNotAllowNullTenantByDefault(): void
+    {
+        $hook = new TenantFilter(7, '', 'orders');
+
+        $condition = $hook->filter('table_main');
+
+        $this->assertSame('table_main.'.Storage::TENANT.' IN (?)', $condition->expression);
+        $this->assertSame([7], $condition->bindings);
+    }
+
+    public function testFilterAllowsNullTenantWhenColumnProvided(): void
+    {
+        $hook = new TenantFilter(7, '', 'orders', 'table_main.'.Storage::TENANT);
+
+        $condition = $hook->filter('table_main');
+
+        $this->assertStringContainsString('table_main.'.Storage::TENANT.' IN (?)', $condition->expression);
+        $this->assertStringContainsString('IS NULL', $condition->expression);
+        $this->assertSame([7], $condition->bindings);
+    }
+
+    public function testFilterJoinLeftPlacesTenantInOnClause(): void
+    {
+        $hook = new TenantFilter(7);
+        $result = $hook->filterJoin('j0', JoinType::Left);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::On, $result->placement);
+        $this->assertSame('j0.'.Storage::TENANT.' IN (?)', $result->condition->expression);
+        $this->assertSame([7], $result->condition->bindings);
+    }
+
+    public function testFilterJoinRightPlacesTenantInWhereClause(): void
+    {
+        $hook = new TenantFilter(7);
+        $result = $hook->filterJoin('j0', JoinType::Right);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertSame('j0.'.Storage::TENANT.' IN (?)', $result->condition->expression);
+        $this->assertSame([7], $result->condition->bindings);
+    }
+
+    public function testFilterJoinFullOuterPlacesTenantInWhereClauseAndAllowsNull(): void
+    {
+        $hook = new TenantFilter(7);
+        $result = $hook->filterJoin('j0', JoinType::FullOuter);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertStringContainsString('j0.'.Storage::TENANT.' IN (?)', $result->condition->expression);
+        $this->assertStringContainsString('IS NULL', $result->condition->expression);
+        $this->assertSame([7], $result->condition->bindings);
+    }
+
+    public function testFilterJoinInnerPlacesTenantInWhereClause(): void
+    {
+        $hook = new TenantFilter(7);
+        $result = $hook->filterJoin('j0', JoinType::Inner);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertSame('j0.'.Storage::TENANT.' IN (?)', $result->condition->expression);
+    }
+
+    public function testFilterJoinCrossPlacesTenantInWhereClause(): void
+    {
+        $hook = new TenantFilter(7);
+        $result = $hook->filterJoin('j0', JoinType::Cross);
+
+        $this->assertNotNull($result);
+        $this->assertSame(Placement::Where, $result->placement);
+        $this->assertSame('j0.'.Storage::TENANT.' IN (?)', $result->condition->expression);
+    }
+}
diff --git a/tests/unit/IDTest.php b/tests/unit/IDTest.php
index 8953097560..68b30f5d3b 100644
--- a/tests/unit/IDTest.php
+++ b/tests/unit/IDTest.php
@@ -7,16 +7,16 @@
 
 class IDTest extends TestCase
 {
-    public function testCustomID(): void
+    public function test_custom_id(): void
     {
         $id = ID::custom('test');
         $this->assertEquals('test', $id);
     }
 
-    public function testUniqueID(): void
+    public function test_unique_id(): void
     {
         $id = ID::unique();
         $this->assertNotEmpty($id);
-        $this->assertIsString($id);
+        $this->assertIsString($id); // @phpstan-ignore method.alreadyNarrowedType
     }
 }
diff --git a/tests/unit/IndexModelTest.php b/tests/unit/IndexModelTest.php
new file mode 100644
index 0000000000..f94c9c0e86
--- /dev/null
+++ b/tests/unit/IndexModelTest.php
@@ -0,0 +1,282 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use ReflectionParameter;
+use Utopia\Database\Document;
+use Utopia\Database\Index;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\Order;
+
+class IndexModelTest extends TestCase
+{
+    public function testConstructorDefaults(): void
+    {
+        $index = Index::key(key: 'idx_test');
+
+        $this->assertSame('idx_test', $index->key);
+        $this->assertSame(IndexType::Key, $index->type);
+        $this->assertSame([], $index->attributes);
+        $this->assertSame([], $index->lengths);
+        $this->assertSame([], $index->orders);
+        $this->assertSame(1, $index->ttl);
+    }
+
+    public function testConstructorWithAllValues(): void
+    {
+        $index = Index::unique(
+            key: 'idx_compound',
+            attributes: ['name', 'email'],
+            lengths: [128, 256],
+            orders: [Order::Asc, Order::Desc],
+            ttl: 3600,
+        );
+
+        $this->assertSame('idx_compound', $index->key);
+        $this->assertSame(IndexType::Unique, $index->type);
+        $this->assertSame(['name', 'email'], $index->attributes);
+        $this->assertSame([128, 256], $index->lengths);
+        $this->assertSame([Order::Asc, Order::Desc], $index->orders);
+        $this->assertSame(3600, $index->ttl);
+    }
+
+    public function testConstructorRejectsStringOrders(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Index order must be Order or null');
+
+        // @phpstan-ignore-next-line
+        Index::key(key: 'idx_enabled', attributes: ['enabled'], orders: ['ASC']);
+    }
+
+    public function testConstructorAcceptsOrderEnum(): void
+    {
+        $index = Index::key(
+            key: 'idx_enabled',
+            attributes: ['enabled'],
+            orders: [Order::Asc, Order::Desc],
+        );
+
+        $this->assertSame([Order::Asc, Order::Desc], $index->orders);
+        $this->assertSame(['ASC', 'DESC'], $index->toDocument()->getAttribute('orders'));
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $index = Index::unique(key: 'idx_email', attributes: ['email'], lengths: [256], orders: [Order::Asc]);
+
+        $doc = $index->toDocument();
+
+        $this->assertSame('idx_email', $doc->getId());
+        $this->assertSame('idx_email', $doc->getAttribute('key'));
+        $this->assertSame('unique', $doc->getAttribute('type'));
+        $this->assertSame(['email'], $doc->getArray('attributes'));
+        $this->assertSame([256], $doc->getAttribute('lengths'));
+        $this->assertSame(['ASC'], $doc->getAttribute('orders'));
+        $this->assertSame(1, $doc->getAttribute('ttl'));
+    }
+
+    public function testArrayAccessMatchesDocumentShape(): void
+    {
+        $index = Index::unique(key: 'idx_email', attributes: ['email'], lengths: [128], orders: [Order::Asc]);
+
+        $this->assertSame('idx_email', $index['$id']);
+        $this->assertSame('idx_email', $index['key']);
+        $this->assertSame(IndexType::Unique->value, $index['type']);
+        $this->assertSame(['email'], $index['attributes']);
+        $this->assertSame('idx_email', $index->getId());
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $original = Index::key(
+            key: 'idx_status_name',
+            attributes: ['status', 'name'],
+            lengths: [32, 128],
+            orders: [Order::Asc, Order::Asc],
+            ttl: 7200,
+        );
+
+        $doc = $original->toDocument();
+        $restored = Index::fromDocument($doc);
+
+        $this->assertSame($original->key, $restored->key);
+        $this->assertSame($original->type, $restored->type);
+        $this->assertSame($original->attributes, $restored->attributes);
+        $this->assertSame($original->lengths, $restored->lengths);
+        $this->assertSame($original->orders, $restored->orders);
+        $this->assertSame($original->ttl, $restored->ttl);
+    }
+
+    public function testFromDocumentWithMinimalDocument(): void
+    {
+        $doc = new Document([
+            '$id' => 'idx_min',
+            'type' => 'key',
+        ]);
+
+        $index = Index::fromDocument($doc);
+
+        $this->assertSame('idx_min', $index->key);
+        $this->assertSame(IndexType::Key, $index->type);
+        $this->assertSame([], $index->attributes);
+        $this->assertSame([], $index->lengths);
+        $this->assertSame([], $index->orders);
+        $this->assertSame(1, $index->ttl);
+    }
+
+    public function testFromDocumentUsesKeyOverId(): void
+    {
+        $doc = new Document([
+            '$id' => 'id_value',
+            'key' => 'key_value',
+            'type' => 'index',
+        ]);
+
+        $index = Index::fromDocument($doc);
+        $this->assertSame('key_value', $index->key);
+    }
+
+    public function testAllIndexTypeValues(): void
+    {
+        $types = [
+            IndexType::Key,
+            IndexType::Index,
+            IndexType::Unique,
+            IndexType::Fulltext,
+            IndexType::Spatial,
+            IndexType::HnswEuclidean,
+            IndexType::HnswCosine,
+            IndexType::HnswDot,
+            IndexType::Trigram,
+            IndexType::Ttl,
+        ];
+
+        foreach ($types as $type) {
+            $index = new Index(key: 'idx_' . $type->value, type: $type, attributes: ['col']);
+            $doc = $index->toDocument();
+            $restored = Index::fromDocument($doc);
+
+            $this->assertSame($type, $restored->type, "Roundtrip failed for type: {$type->value}");
+        }
+    }
+
+    public function testWithTTL(): void
+    {
+        $index = Index::ttl(key: 'idx_ttl', attributes: ['expiresAt'], ttl: 86400);
+
+        $doc = $index->toDocument();
+        $this->assertSame(86400, $doc->getAttribute('ttl'));
+
+        $restored = Index::fromDocument($doc);
+        $this->assertSame(86400, $restored->ttl);
+    }
+
+    public function testWithNullLengthsAndOrders(): void
+    {
+        $index = Index::key(key: 'idx_mixed', attributes: ['a', 'b'], lengths: [128, null], orders: [Order::Asc, null]);
+
+        $doc = $index->toDocument();
+        $this->assertSame([128, null], $doc->getAttribute('lengths'));
+        $this->assertSame(['ASC', null], $doc->getAttribute('orders'));
+
+        $restored = Index::fromDocument($doc);
+        $this->assertSame([128, null], $restored->lengths);
+        $this->assertSame([Order::Asc, null], $restored->orders);
+    }
+
+    public function testMultipleAttributeIndex(): void
+    {
+        $index = Index::key(key: 'idx_multi', attributes: ['firstName', 'lastName', 'email'], lengths: [64, 64, 256], orders: [Order::Asc, Order::Asc, Order::Desc]);
+
+        $doc = $index->toDocument();
+        $restored = Index::fromDocument($doc);
+
+        $this->assertCount(3, $restored->attributes);
+        $this->assertCount(3, $restored->lengths);
+        $this->assertCount(3, $restored->orders);
+    }
+
+    /**
+     * @return array<string, array{string, IndexType}>
+     */
+    public static function factories(): array
+    {
+        return [
+            'key' => ['key', IndexType::Key],
+            'index' => ['index', IndexType::Index],
+            'unique' => ['unique', IndexType::Unique],
+            'fullText' => ['fullText', IndexType::Fulltext],
+            'spatial' => ['spatial', IndexType::Spatial],
+            'object' => ['object', IndexType::Object],
+            'hnswEuclidean' => ['hnswEuclidean', IndexType::HnswEuclidean],
+            'hnswCosine' => ['hnswCosine', IndexType::HnswCosine],
+            'hnswDot' => ['hnswDot', IndexType::HnswDot],
+            'trigram' => ['trigram', IndexType::Trigram],
+            'ttl' => ['ttl', IndexType::Ttl],
+        ];
+    }
+
+    #[DataProvider('factories')]
+    public function testFactorySetsTypeAndDefaults(string $factory, IndexType $type): void
+    {
+        $index = Index::{$factory}(key: 'idx');
+
+        $this->assertInstanceOf(Index::class, $index);
+        $this->assertSame('idx', $index->key);
+        $this->assertSame($type, $index->type);
+        $this->assertSame([], $index->attributes);
+        $this->assertSame([], $index->lengths);
+        $this->assertSame([], $index->orders);
+        $this->assertSame(1, $index->ttl);
+    }
+
+    public function testFactoryOmitsTypeParameter(): void
+    {
+        $names = array_map(
+            static fn (ReflectionParameter $parameter): string => $parameter->getName(),
+            (new ReflectionMethod(Index::class, 'key'))->getParameters(),
+        );
+
+        $this->assertSame(false, in_array('type', $names, true));
+    }
+
+    public function testFactoryForwardsOptionalArguments(): void
+    {
+        $index = Index::key(
+            key: 'idx',
+            attributes: ['name', 'email'],
+            lengths: [128, 256],
+            orders: [Order::Asc, Order::Desc],
+            ttl: 3600,
+        );
+
+        $this->assertSame('idx', $index->key);
+        $this->assertSame(IndexType::Key, $index->type);
+        $this->assertSame(['name', 'email'], $index->attributes);
+        $this->assertSame([128, 256], $index->lengths);
+        $this->assertSame([Order::Asc, Order::Desc], $index->orders);
+        $this->assertSame(3600, $index->ttl);
+    }
+
+    public function testKeyFactory(): void
+    {
+        $index = Index::key('idx_name', ['name']);
+
+        $this->assertSame('idx_name', $index->key);
+        $this->assertSame(IndexType::Key, $index->type);
+        $this->assertSame(['name'], $index->attributes);
+    }
+
+    public function testFullTextFactory(): void
+    {
+        $index = Index::fullText('idx_body', ['body']);
+
+        $this->assertSame('idx_body', $index->key);
+        $this->assertSame(IndexType::Fulltext, $index->type);
+        $this->assertSame(['body'], $index->attributes);
+    }
+}
diff --git a/tests/unit/Indexes/IndexValidationTest.php b/tests/unit/Indexes/IndexValidationTest.php
new file mode 100644
index 0000000000..368ec7fe3d
--- /dev/null
+++ b/tests/unit/Indexes/IndexValidationTest.php
@@ -0,0 +1,288 @@
+<?php
+
+namespace Tests\Unit\Indexes;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Index as IndexException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+
+class IndexValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::TTLIndexes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createIndex')->willReturn(true);
+        $this->adapter->method('deleteIndex')->willReturn(true);
+        $this->adapter->method('renameIndex')->willReturn(true);
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, Document>  $indexes
+     */
+    private function setupCollection(string $id, array $attributes = [], array $indexes = []): void
+    {
+        $collection = new Document([
+            '$id' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => true,
+        ]);
+        $meta = $this->metaCollection();
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($id, $collection, $meta) {
+                if ($col->getId() === Database::METADATA && $docId === $id) {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+    }
+
+    public function testCreateIndexValidatesAttributeExists(): void
+    {
+        $this->setupCollection('testCol');
+
+        $this->expectException(IndexException::class);
+        $this->database->createIndex('testCol', Index::key(key: 'idx1', attributes: ['nonexistent']));
+    }
+
+    public function testCreateIndexEnforcesIndexCountLimit(): void
+    {
+        $adapter = self::createStub(Adapter::class);
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn('string');
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(1);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(5);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [Capability::Index, Capability::IndexArray, Capability::UniqueIndex, Capability::DefinedAttributes]);
+        });
+        $adapter->method('createIndex')->willReturn(true);
+
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $collection = new Document([
+            '$id' => 'testCol',
+            '$collection' => Database::METADATA,
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any())],
+            'name' => 'testCol',
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($collection) {
+                if ($col->getId() === Database::METADATA && $docId === 'testCol') {
+                    return $collection;
+                }
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return new Document(Database::collectionDefinition());
+                }
+
+                return new Document();
+            }
+        );
+        $adapter->method('updateDocument')->willReturnArgument(2);
+
+        $db = new Database($adapter, new Cache(new None()));
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        $this->expectException(LimitException::class);
+        $this->expectExceptionMessage('Index limit');
+        $db->createIndex('testCol', Index::key(key: 'idx_name', attributes: ['name']));
+    }
+
+    public function testCreateIndexRejectsDuplicateKey(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $indexes = [
+            new Document(['$id' => 'idx_name', 'key' => 'idx_name', 'type' => 'key', 'attributes' => ['name'], 'lengths' => [], 'orders' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes, $indexes);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Index already exists');
+        $this->database->createIndex('testCol', Index::key(key: 'idx_name', attributes: ['name']));
+    }
+
+    public function testCreateIndexMissingAttributesThrows(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Missing attributes');
+        $this->database->createIndex('testCol', Index::key(key: 'idx_empty'));
+    }
+
+    public function testCreateIndexSucceedsWithValidConfig(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes);
+
+        $result = $this->database->createIndex('testCol', Index::key(key: 'idx_name', attributes: ['name']));
+        $this->assertTrue($result);
+    }
+
+    public function testDeleteIndexThrowsOnNotFound(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Index not found');
+        $this->database->deleteIndex('testCol', 'nonexistent');
+    }
+
+    public function testRenameIndexThrowsOnNotFound(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Index not found');
+        $this->database->renameIndex('testCol', 'nonexistent', 'newname');
+    }
+
+    public function testRenameIndexThrowsOnExistingName(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+            new Document(['$id' => 'title', 'key' => 'title', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $indexes = [
+            new Document(['$id' => 'idx_name', 'key' => 'idx_name', 'type' => 'key', 'attributes' => ['name'], 'lengths' => [], 'orders' => []]),
+            new Document(['$id' => 'idx_title', 'key' => 'idx_title', 'type' => 'key', 'attributes' => ['title'], 'lengths' => [], 'orders' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes, $indexes);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Index name already used');
+        $this->database->renameIndex('testCol', 'idx_name', 'idx_title');
+    }
+
+    public function testRenameIndexSucceeds(): void
+    {
+        $attributes = [
+            new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 128, 'required' => false, 'array' => false, 'signed' => true, 'filters' => []]),
+        ];
+        $indexes = [
+            new Document(['$id' => 'idx_name', 'key' => 'idx_name', 'type' => 'key', 'attributes' => ['name'], 'lengths' => [], 'orders' => []]),
+        ];
+        $this->setupCollection('testCol', $attributes, $indexes);
+
+        $result = $this->database->renameIndex('testCol', 'idx_name', 'idx_new_name');
+        $this->assertTrue($result);
+    }
+}
diff --git a/tests/unit/Loading/LazyProxyTest.php b/tests/unit/Loading/LazyProxyTest.php
new file mode 100644
index 0000000000..d4fc367104
--- /dev/null
+++ b/tests/unit/Loading/LazyProxyTest.php
@@ -0,0 +1,189 @@
+<?php
+
+namespace Tests\Unit\Loading;
+
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Loading\BatchLoader;
+use Utopia\Database\Loading\LazyProxy;
+
+class LazyProxyTest extends TestCase
+{
+    private Database&Stub $db;
+
+    private BatchLoader $batchLoader;
+
+    protected function setUp(): void
+    {
+        $this->db = self::createStub(Database::class);
+        $this->batchLoader = new BatchLoader($this->db);
+    }
+
+    public function testConstructorRegistersWithBatchLoader(): void
+    {
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $this->assertFalse($proxy->isResolved());
+        $this->assertEquals('u1', $proxy->getId());
+    }
+
+    public function testIsResolvedReturnsFalseInitially(): void
+    {
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $this->assertFalse($proxy->isResolved());
+    }
+
+    public function testResolveWithPopulatesDocumentData(): void
+    {
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $proxy->resolveWith($doc);
+
+        $this->assertTrue($proxy->isResolved());
+        $this->assertEquals('Alice', $proxy->getAttribute('name'));
+    }
+
+    public function testIsResolvedReturnsTrueAfterResolveWith(): void
+    {
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $proxy->resolveWith(new Document(['$id' => 'u1']));
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testGetAttributeTriggersLazyResolution(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Bob']);
+        $this->db->method('find')->willReturn([$doc]);
+
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $name = $proxy->getAttribute('name');
+
+        $this->assertEquals('Bob', $name);
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testOffsetGetTriggersLazyResolution(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'email' => 'bob@test.com']);
+        $this->db->method('find')->willReturn([$doc]);
+
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $email = $proxy['email'];
+
+        $this->assertEquals('bob@test.com', $email);
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testOffsetExistsTriggersLazyResolution(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $this->db->method('find')->willReturn([$doc]);
+
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $exists = isset($proxy['name']);
+
+        $this->assertTrue($exists);
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testGetArrayCopyTriggersLazyResolution(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $this->db->method('find')->willReturn([$doc]);
+
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $copy = $proxy->getArrayCopy();
+
+        $this->assertArrayHasKey('name', $copy);
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testIsEmptyTriggersLazyResolution(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $this->db->method('find')->willReturn([$doc]);
+
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $empty = $proxy->isEmpty();
+
+        $this->assertFalse($empty);
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testResolveWithNullDocument(): void
+    {
+        $proxy = new LazyProxy($this->batchLoader, 'users', 'u1');
+        $proxy->resolveWith(null);
+
+        $this->assertTrue($proxy->isResolved());
+    }
+
+    public function testMultipleProxiesBatchResolvedTogether(): void
+    {
+        $db = $this->createMock(Database::class);
+        $batchLoader = new BatchLoader($db);
+
+        $doc1 = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $doc2 = new Document(['$id' => 'u2', 'name' => 'Bob']);
+
+        $db->expects($this->once())
+            ->method('find')
+            ->willReturn([$doc1, $doc2]);
+
+        $proxy1 = new LazyProxy($batchLoader, 'users', 'u1');
+        $proxy2 = new LazyProxy($batchLoader, 'users', 'u2');
+
+        $proxy1->getAttribute('name');
+
+        $this->assertTrue($proxy1->isResolved());
+        $this->assertTrue($proxy2->isResolved());
+        $this->assertEquals('Alice', $proxy1->getAttribute('name'));
+        $this->assertEquals('Bob', $proxy2->getAttribute('name'));
+    }
+
+    public function testBatchLoaderResolveWithNoPendingReturnsNull(): void
+    {
+        $result = $this->batchLoader->resolve('nonexistent', 'id1');
+        $this->assertNull($result);
+    }
+
+    public function testBatchLoaderResolveClearsPendingAfterResolution(): void
+    {
+        $db = $this->createMock(Database::class);
+        $batchLoader = new BatchLoader($db);
+
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $db->expects($this->once())
+            ->method('find')
+            ->willReturn([$doc]);
+
+        $proxy = new LazyProxy($batchLoader, 'users', 'u1');
+        $batchLoader->resolve('users', 'u1');
+
+        $result = $batchLoader->resolve('users', 'u1');
+        $this->assertNull($result);
+    }
+
+    public function testBatchLoaderResolveFetchesAllPendingAtOnce(): void
+    {
+        $db = $this->createMock(Database::class);
+        $batchLoader = new BatchLoader($db);
+
+        $doc1 = new Document(['$id' => 'u1', 'name' => 'Alice']);
+        $doc2 = new Document(['$id' => 'u2', 'name' => 'Bob']);
+        $doc3 = new Document(['$id' => 'u3', 'name' => 'Charlie']);
+
+        $db->expects($this->once())
+            ->method('find')
+            ->willReturn([$doc1, $doc2, $doc3]);
+
+        new LazyProxy($batchLoader, 'users', 'u1');
+        new LazyProxy($batchLoader, 'users', 'u2');
+        new LazyProxy($batchLoader, 'users', 'u3');
+
+        $result = $batchLoader->resolve('users', 'u1');
+        $this->assertInstanceOf(Document::class, $result);
+        $this->assertEquals('u1', $result->getId());
+    }
+}
diff --git a/tests/unit/Loading/NPlusOneDetectorTest.php b/tests/unit/Loading/NPlusOneDetectorTest.php
new file mode 100644
index 0000000000..d31a248947
--- /dev/null
+++ b/tests/unit/Loading/NPlusOneDetectorTest.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Tests\Unit\Loading;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Loading\NPlusOneDetector;
+
+class NPlusOneDetectorTest extends TestCase
+{
+    public function testDetectsExcessiveQueries(): void
+    {
+        $detected = new \stdClass();
+        $detected->value = false;
+        $detector = new NPlusOneDetector(3, function () use ($detected) {
+            $detected->value = true;
+        });
+
+        $doc = new Document(['$id' => '1', '$collection' => 'users']);
+
+        $detector->handle(Event::DocumentFind, $doc);
+        $detector->handle(Event::DocumentFind, $doc);
+        $this->assertFalse($detected->value);
+
+        $detector->handle(Event::DocumentFind, $doc);
+        $this->assertNotEmpty($detector->getViolations());
+        $this->assertTrue($detected->value);
+    }
+
+    public function testIgnoresNonQueryEvents(): void
+    {
+        $detector = new NPlusOneDetector(2);
+
+        $detector->handle(Event::DocumentCreate, new Document(['$collection' => 'users']));
+        $detector->handle(Event::DocumentCreate, new Document(['$collection' => 'users']));
+        $detector->handle(Event::DocumentCreate, new Document(['$collection' => 'users']));
+
+        $this->assertEmpty($detector->getViolations());
+    }
+
+    public function testGetQueryCounts(): void
+    {
+        $detector = new NPlusOneDetector(100);
+
+        $detector->handle(Event::DocumentFind, new Document(['$collection' => 'users']));
+        $detector->handle(Event::DocumentFind, new Document(['$collection' => 'users']));
+        $detector->handle(Event::DocumentFind, new Document(['$collection' => 'posts']));
+
+        $counts = $detector->getQueryCounts();
+        $this->assertEquals(2, $counts['document_find:users']);
+        $this->assertEquals(1, $counts['document_find:posts']);
+    }
+
+    public function testReset(): void
+    {
+        $detector = new NPlusOneDetector(5);
+
+        $detector->handle(Event::DocumentFind, new Document(['$collection' => 'users']));
+        $detector->reset();
+
+        $this->assertEmpty($detector->getQueryCounts());
+    }
+}
diff --git a/tests/unit/MariaDBTimeoutTest.php b/tests/unit/MariaDBTimeoutTest.php
new file mode 100644
index 0000000000..3f986f23a9
--- /dev/null
+++ b/tests/unit/MariaDBTimeoutTest.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\MariaDB;
+
+final class MariaDBTimeoutTest extends TestCase
+{
+    public function testRepeatedSetAndClearOnlyWriteChangedSessionValues(): void
+    {
+        $statements = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('exec')
+            ->willReturnCallback(function (string $sql) use (&$statements): int {
+                $statements[] = $sql;
+
+                return 0;
+            });
+
+        $adapter = new MariaDB($pdo);
+        $adapter->setTimeout(1000);
+        $adapter->setTimeout(1000);
+        $adapter->clearTimeout();
+        $adapter->clearTimeout();
+
+        $this->assertSame([
+            'SET max_statement_time = 1.000000',
+            'SET max_statement_time = 0.000000',
+        ], $statements);
+    }
+
+    public function testTimeoutUsesFixedPointFormatting(): void
+    {
+        $milliseconds = PHP_INT_MAX;
+        $expected = 'SET max_statement_time = '.\sprintf('%.6F', $milliseconds / 1000.0);
+
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('exec')
+            ->with($expected)
+            ->willReturn(0);
+
+        $adapter = new MariaDB($pdo);
+        $adapter->setTimeout($milliseconds);
+    }
+}
diff --git a/tests/unit/MirrorTest.php b/tests/unit/MirrorTest.php
new file mode 100644
index 0000000000..a15d1b6e9f
--- /dev/null
+++ b/tests/unit/MirrorTest.php
@@ -0,0 +1,161 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Mirror;
+
+class MirrorTest extends TestCase
+{
+    public function testSetDatabaseUpdatesMirrorAndChildren(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror->setDatabase('utopiaTests');
+
+        $this->assertSame('utopiaTests', $mirror->getDatabase());
+        $this->assertSame('utopiaTests', $source->getDatabase());
+        $this->assertSame('utopiaTests', $destination->getDatabase());
+    }
+
+    public function testSetNamespaceUpdatesMirrorAndChildren(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror->setNamespace('myapp');
+
+        $this->assertSame('myapp', $mirror->getNamespace());
+        $this->assertSame('myapp', $source->getNamespace());
+        $this->assertSame('myapp', $destination->getNamespace());
+    }
+
+    public function testSetTenantUpdatesMirrorAndChildren(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror->setTenant(7);
+
+        $this->assertSame(7, $mirror->getTenant());
+        $this->assertSame(7, $source->getTenant());
+        $this->assertSame(7, $destination->getTenant());
+    }
+
+    public function testSetSharedTablesUpdatesMirrorAndChildren(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror->setSharedTables(true);
+
+        $this->assertTrue($mirror->getSharedTables());
+        $this->assertTrue($source->getSharedTables());
+        $this->assertTrue($destination->getSharedTables());
+    }
+
+    public function testCreateCreatesMetadataOnDestination(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror
+            ->setDatabase('utopiaTests')
+            ->setNamespace('myapp')
+            ->create();
+
+        $this->assertTrue($source->exists('utopiaTests'));
+        $this->assertTrue($source->exists('utopiaTests', Database::METADATA));
+        $this->assertTrue($destination->exists('utopiaTests'));
+        $this->assertTrue($destination->exists('utopiaTests', Database::METADATA));
+    }
+
+    public function testListCollectionsHidesSourceOnlyUpgrades(): void
+    {
+        [$mirror, $source] = $this->pair();
+
+        $mirror
+            ->setDatabase('utopiaTests')
+            ->setNamespace('myapp')
+            ->create();
+
+        $mirror->createCollection(new Collection(id: 'actors', permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+        ]));
+
+        $listed = $mirror->listCollections();
+        $ids = \array_map(static fn ($collection): string => $collection->getId(), $listed);
+
+        $this->assertSame(['actors'], $ids);
+        $this->assertFalse($source->getCollection('upgrades')->isEmpty());
+    }
+
+    public function testSkipValidationRestoresSourceAndDestination(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $this->assertTrue($mirror->isValidationEnabled());
+        $this->assertTrue($source->isValidationEnabled());
+        $this->assertTrue($destination->isValidationEnabled());
+
+        $mirror->skipValidation(function () use ($mirror, $source, $destination) {
+            $this->assertFalse($mirror->isValidationEnabled());
+            $this->assertFalse($source->isValidationEnabled());
+            $this->assertFalse($destination->isValidationEnabled());
+        });
+
+        $this->assertTrue($mirror->isValidationEnabled());
+        $this->assertTrue($source->isValidationEnabled());
+        $this->assertTrue($destination->isValidationEnabled());
+    }
+
+    public function testDisableValidationDelegatesToSourceAndDestination(): void
+    {
+        [$mirror, $source, $destination] = $this->pair();
+
+        $mirror->disableValidation();
+
+        $this->assertFalse($mirror->isValidationEnabled());
+        $this->assertFalse($source->isValidationEnabled());
+        $this->assertFalse($destination->isValidationEnabled());
+
+        $mirror->enableValidation();
+
+        $this->assertTrue($mirror->isValidationEnabled());
+        $this->assertTrue($source->isValidationEnabled());
+        $this->assertTrue($destination->isValidationEnabled());
+    }
+
+    public function testCreateThrowsWhenDestinationCreateFails(): void
+    {
+        $source = new Database(new Memory(), new Cache(new None()));
+        $destination = new Database(new class () extends Memory {
+            public function create(string $name): bool
+            {
+                throw new RuntimeException('destination create failed');
+            }
+        }, new Cache(new None()));
+        $mirror = new Mirror($source, $destination);
+
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('destination create failed');
+
+        $mirror->setDatabase('utopiaTests')->setNamespace('myapp')->create();
+    }
+
+    /**
+     * @return array{0: Mirror, 1: Database, 2: Database}
+     */
+    private function pair(): array
+    {
+        $source = new Database(new Memory(), new Cache(new None()));
+        $destination = new Database(new Memory(), new Cache(new None()));
+
+        return [new Mirror($source, $destination), $source, $destination];
+    }
+}
diff --git a/tests/unit/MongoAttributesSupportTest.php b/tests/unit/MongoAttributesSupportTest.php
new file mode 100644
index 0000000000..e341a922d7
--- /dev/null
+++ b/tests/unit/MongoAttributesSupportTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\Mongo;
+use Utopia\Database\Capability;
+
+final class MongoAttributesSupportTest extends TestCase
+{
+    public function testDefinedAttributesFollowsSupportFlag(): void
+    {
+        $adapter = new class () extends Mongo {
+            public function __construct()
+            {
+            }
+        };
+
+        $this->assertTrue($adapter->supports(Capability::DefinedAttributes));
+
+        $adapter->setSupportForAttributes(false);
+        $this->assertFalse($adapter->supports(Capability::DefinedAttributes));
+
+        $adapter->setSupportForAttributes(true);
+        $this->assertTrue($adapter->supports(Capability::DefinedAttributes));
+    }
+}
diff --git a/tests/unit/MongoIdentifierTest.php b/tests/unit/MongoIdentifierTest.php
new file mode 100644
index 0000000000..6c1ad67f68
--- /dev/null
+++ b/tests/unit/MongoIdentifierTest.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\Mongo;
+use Utopia\Database\Document;
+use Utopia\Database\Storage;
+
+final class MongoIdentifierTest extends TestCase
+{
+    public function testReplaceCharsStringifiesObjectSequence(): void
+    {
+        $sequence = new class () {
+            public function __toString(): string
+            {
+                return '507f1f77bcf86cd799439011';
+            }
+        };
+
+        $adapter = new class () extends Mongo {
+            public function __construct()
+            {
+            }
+        };
+
+        $replaceChars = new ReflectionMethod($adapter, 'replaceChars');
+        $result = $replaceChars->invoke($adapter, '_', '$', [
+            Storage::SEQUENCE => $sequence,
+            Storage::UID => 'movies',
+        ]);
+        $this->assertIsArray($result);
+
+        $this->assertSame('507f1f77bcf86cd799439011', $result[Document::SEQUENCE]);
+        $this->assertSame('movies', $result[Document::ID]);
+        $this->assertArrayNotHasKey(Storage::SEQUENCE, $result);
+    }
+}
diff --git a/tests/unit/MongoPermissionStringsTest.php b/tests/unit/MongoPermissionStringsTest.php
index 25cf69da9a..b68162d8f8 100644
--- a/tests/unit/MongoPermissionStringsTest.php
+++ b/tests/unit/MongoPermissionStringsTest.php
@@ -3,10 +3,9 @@
 namespace Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use ReflectionClass;
-use ReflectionMethod;
-use Utopia\Database\Adapter\Mongo;
-use Utopia\Database\Database;
+use Utopia\Database\Hook\Mongo\PermissionFilter;
+use Utopia\Database\PermissionType;
+use Utopia\Database\Storage;
 use Utopia\Database\Validator\Authorization;
 
 class MongoPermissionStringsTest extends TestCase
@@ -15,17 +14,17 @@ public function testPeriodInRoleIsLiteralNotRegexWildcard(): void
     {
         $this->assertSame(
             ['read("user:alice.")'],
-            $this->permissionStrings(['user:alice.'], Database::PERMISSION_READ)
+            $this->permissionStrings(['user:alice.'], PermissionType::Read)
         );
     }
 
     public function testMassReadDotPaddingStaysExact(): void
     {
-        $role = 'user:a' . \str_repeat('.', 19);
+        $role = 'user:a'.\str_repeat('.', 19);
 
         $this->assertSame(
-            ['read("' . $role . '")'],
-            $this->permissionStrings([$role], Database::PERMISSION_READ)
+            ['read("'.$role.'")'],
+            $this->permissionStrings([$role], PermissionType::Read)
         );
     }
 
@@ -33,7 +32,7 @@ public function testMatchingIsCaseSensitiveAndUsesRequestedType(): void
     {
         $this->assertSame(
             ['update("user:alice")'],
-            $this->permissionStrings(['user:alice'], Database::PERMISSION_UPDATE)
+            $this->permissionStrings(['user:alice'], PermissionType::Update)
         );
     }
 
@@ -41,19 +40,18 @@ public function testMultipleRolesMapToExactPermissionStrings(): void
     {
         $this->assertSame(
             ['read("user:alice")', 'read("users")'],
-            $this->permissionStrings(['user:alice', 'users'], Database::PERMISSION_READ)
+            $this->permissionStrings(['user:alice', 'users'], PermissionType::Read)
         );
     }
 
     public function testEmptyRolesProduceEmptyList(): void
     {
-        $this->assertSame([], $this->permissionStrings([], Database::PERMISSION_READ));
+        $this->assertSame([], $this->permissionStrings([], PermissionType::Read));
     }
 
     public function testValuesAreStringsNotRegex(): void
     {
-        foreach ($this->permissionStrings(['user:alice.'], Database::PERMISSION_READ) as $value) {
-            $this->assertIsString($value);
+        foreach ($this->permissionStrings(['user:alice.'], PermissionType::Read) as $value) {
             $this->assertStringStartsWith('read("', $value);
             $this->assertStringEndsWith('")', $value);
         }
@@ -63,7 +61,7 @@ public function testValuesAreStringsNotRegex(): void
      * @param list<string> $roles
      * @return list<string>
      */
-    private function permissionStrings(array $roles, string $type): array
+    private function permissionStrings(array $roles, PermissionType $type): array
     {
         $authorization = new Authorization();
         $authorization->enable();
@@ -72,14 +70,25 @@ private function permissionStrings(array $roles, string $type): array
             $authorization->addRole($role);
         }
 
-        $adapter = (new ReflectionClass(Mongo::class))->newInstanceWithoutConstructor();
-        $adapter->setAuthorization($authorization);
+        $filters = (new PermissionFilter($authorization))->applyFilters([], 'documents', $type->value);
+        $permissionFilter = $filters[Storage::PERMISSIONS] ?? null;
+        if (! \is_array($permissionFilter)) {
+            return [];
+        }
 
-        $method = new ReflectionMethod(Mongo::class, 'permissionStrings');
+        $values = $permissionFilter['$in'] ?? [];
+        if (! \is_array($values)) {
+            return [];
+        }
 
-        /** @var list<string> $values */
-        $values = $method->invoke($adapter, $type);
+        $strings = [];
+        foreach ($values as $value) {
+            if (! \is_string($value)) {
+                $this->fail('Permission $in values must be strings');
+            }
+            $strings[] = $value;
+        }
 
-        return $values;
+        return $strings;
     }
 }
diff --git a/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php b/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
new file mode 100644
index 0000000000..883aa4d272
--- /dev/null
+++ b/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
@@ -0,0 +1,267 @@
+<?php
+
+namespace Tests\Unit\ObjectAttribute;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Query\Schema\ColumnType;
+
+class ObjectAttributeValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Objects,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+        $this->adapter->method('createAttribute')->willReturn(true);
+        $this->adapter->method('getSequences')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     */
+    private function makeCollection(string $id, array $attributes = []): Document
+    {
+        return new Document([
+            '$id' => $id,
+            '$sequence' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $collections
+     */
+    private function setupCollections(array $collections): void
+    {
+        $meta = $this->metaCollection();
+        $map = [];
+        foreach ($collections as $col) {
+            $map[$col->getId()] = $col;
+        }
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta, $map) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+                if ($col->getId() === Database::METADATA && isset($map[$docId])) {
+                    return $map[$docId];
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+    }
+
+    public function testObjectAttributeInvalidCases(): void
+    {
+        $metaAttr = new Document([
+            '$id' => 'meta', 'key' => 'meta',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('objInvalid', [$metaAttr]);
+        $this->setupCollections([$col]);
+
+        $exceptionThrown = false;
+        try {
+            $this->database->createDocument('objInvalid', new Document([
+                '$id' => 'invalid1',
+                '$permissions' => [Permission::read(Role::any())],
+                'meta' => 'this is a string not an object',
+            ]));
+        } catch (\Exception $e) {
+            $exceptionThrown = true;
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+        $this->assertTrue($exceptionThrown, 'Expected Structure exception for string value');
+
+        $exceptionThrown = false;
+        try {
+            $this->database->createDocument('objInvalid', new Document([
+                '$id' => 'invalid2',
+                '$permissions' => [Permission::read(Role::any())],
+                'meta' => 12345,
+            ]));
+        } catch (\Exception $e) {
+            $exceptionThrown = true;
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+        $this->assertTrue($exceptionThrown, 'Expected Structure exception for integer value');
+
+        $exceptionThrown = false;
+        try {
+            $this->database->createDocument('objInvalid', new Document([
+                '$id' => 'invalid3',
+                '$permissions' => [Permission::read(Role::any())],
+                'meta' => true,
+            ]));
+        } catch (\Exception $e) {
+            $exceptionThrown = true;
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+        $this->assertTrue($exceptionThrown, 'Expected Structure exception for boolean value');
+    }
+
+    public function testObjectAttributeDefaults(): void
+    {
+        $emptyDefault = new Document([
+            '$id' => 'metaDefaultEmpty', 'key' => 'metaDefaultEmpty',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => false, 'default' => [],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $settingsDefault = new Document([
+            '$id' => 'settings', 'key' => 'settings',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => false, 'default' => ['config' => ['theme' => 'light', 'lang' => 'en']],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $profileRequired = new Document([
+            '$id' => 'profile', 'key' => 'profile',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $profile2Default = new Document([
+            '$id' => 'profile2', 'key' => 'profile2',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => false, 'default' => ['name' => 'anon'],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $miscNull = new Document([
+            '$id' => 'misc', 'key' => 'misc',
+            'type' => ColumnType::Object->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('objDefaults', [$emptyDefault, $settingsDefault, $profileRequired, $profile2Default, $miscNull]);
+        $this->setupCollections([$col]);
+
+        $exceptionThrown = false;
+        try {
+            $this->database->createDocument('objDefaults', new Document([
+                '$id' => 'def1',
+                '$permissions' => [Permission::read(Role::any())],
+            ]));
+        } catch (\Exception $e) {
+            $exceptionThrown = true;
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+        $this->assertTrue($exceptionThrown, 'Expected Structure exception for missing required object attribute');
+
+        $doc = $this->database->createDocument('objDefaults', new Document([
+            '$id' => 'def2',
+            '$permissions' => [Permission::read(Role::any())],
+            'profile' => ['name' => 'provided'],
+        ]));
+
+        $this->assertIsArray($doc->getAttribute('metaDefaultEmpty'));
+        $this->assertEmpty($doc->getAttribute('metaDefaultEmpty'));
+
+        $settings = $doc->getArray('settings');
+        $config = $settings['config'] ?? null;
+        $this->assertIsArray($config);
+        $this->assertEquals('light', $config['theme'] ?? null);
+
+        $profile = $doc->getArray('profile');
+        $this->assertEquals('provided', $profile['name'] ?? null);
+
+        $profile2 = $doc->getArray('profile2');
+        $this->assertEquals('anon', $profile2['name'] ?? null);
+
+        $this->assertNull($doc->getAttribute('misc'));
+    }
+}
diff --git a/tests/unit/ObjectFilterTest.php b/tests/unit/ObjectFilterTest.php
new file mode 100644
index 0000000000..a04369ae11
--- /dev/null
+++ b/tests/unit/ObjectFilterTest.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Memory;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Query\Schema\ColumnType;
+
+final class ObjectFilterTest extends TestCase
+{
+    public function testObjectFilterPreservesEmptyObjectsAndArrays(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $collection = new Document([
+            'attributes' => [new Document([
+                '$id' => 'meta',
+                'array' => false,
+                'filters' => [ColumnType::Object->value],
+            ])],
+        ]);
+        $document = new Document([
+            'meta' => [
+                'emptyObject' => new \stdClass(),
+                'emptyArray' => [],
+                'nested' => [new \stdClass(), ['value' => 1]],
+            ],
+        ]);
+
+        $encoded = $database->encode($collection, $document);
+        $this->assertSame('{"emptyObject":{},"emptyArray":[],"nested":[{},{"value":1}]}', $encoded->getAttribute('meta'));
+
+        $decoded = $database->decode($collection, $encoded)->getAttribute('meta');
+        $this->assertIsArray($decoded);
+        $this->assertInstanceOf(\stdClass::class, $decoded['emptyObject']);
+        $this->assertSame([], $decoded['emptyArray']);
+        $nested = $decoded['nested'];
+        $this->assertIsArray($nested);
+        $this->assertInstanceOf(\stdClass::class, $nested[0]);
+        $this->assertSame(['value' => 1], $nested[1]);
+    }
+
+    public function testObjectFilterEncodesTopLevelEmptyObject(): void
+    {
+        $database = new Database(new Memory(), new Cache(new None()));
+        $collection = new Document([
+            'attributes' => [new Document([
+                '$id' => 'meta',
+                'array' => false,
+                'filters' => [ColumnType::Object->value],
+            ])],
+        ]);
+
+        $encoded = $database->encode($collection, new Document(['meta' => new \stdClass()]));
+        $this->assertSame('{}', $encoded->getAttribute('meta'));
+        $this->assertInstanceOf(
+            \stdClass::class,
+            $database->decode($collection, $encoded)->getAttribute('meta'),
+        );
+    }
+}
diff --git a/tests/unit/Operator/OperatorValidationTest.php b/tests/unit/Operator/OperatorValidationTest.php
new file mode 100644
index 0000000000..0486632c98
--- /dev/null
+++ b/tests/unit/Operator/OperatorValidationTest.php
@@ -0,0 +1,1646 @@
+<?php
+
+namespace Tests\Unit\Operator;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Operator as OperatorException;
+use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\Validator\Operator as OperatorValidator;
+use Utopia\Query\Schema\ColumnType;
+
+class OperatorValidationTest extends TestCase
+{
+    /**
+     * @param  array<int, Attribute>  $attributes
+     */
+    private function makeCollection(array $attributes): Document
+    {
+        $attrDocs = [];
+        foreach ($attributes as $attr) {
+            $attrDocs[] = $attr->toDocument();
+        }
+
+        return new Document([
+            '$id' => 'test_collection',
+            '$collection' => Database::METADATA,
+            'name' => 'test_collection',
+            'attributes' => $attrDocs,
+            'indexes' => [],
+        ]);
+    }
+
+    /**
+     * @param  array<int, Attribute>  $attributes
+     */
+    private function makeValidator(array $attributes, ?Document $currentDoc = null): OperatorValidator
+    {
+        return new OperatorValidator($this->makeCollection($attributes), $currentDoc);
+    }
+
+    /**
+     * @param  array<int, mixed>  $values
+     */
+    private function makeOperator(OperatorType $method, string $attribute, array $values = []): Operator
+    {
+        return new Operator($method, $attribute, $values);
+    }
+
+    public function testIncrementOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'count', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementExceedsMax(): void
+    {
+        $currentDoc = new Document(['count' => Database::MAX_INT - 5]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'count', [10]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would overflow', $validator->getDescription());
+    }
+
+    public function testDecrementOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'count', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDecrementBelowMin(): void
+    {
+        $currentDoc = new Document(['count' => Database::MIN_INT + 5]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'count', [10]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would underflow', $validator->getDescription());
+    }
+
+    public function testMultiplyOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'value', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testMultiplyOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'score', [2.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testMultiplyViolatesRange(): void
+    {
+        $currentDoc = new Document(['value' => Database::MAX_INT]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'value', [2]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would overflow', $validator->getDescription());
+    }
+
+    public function testMultiplyNegative(): void
+    {
+        $currentDoc = new Document(['value' => Database::MAX_INT]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'value', [-2]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would underflow', $validator->getDescription());
+    }
+
+    public function testDivideOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [2]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDivideOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'score', [3.0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDivideByZero(): void
+    {
+        $this->expectException(OperatorException::class);
+        $this->expectExceptionMessage('Division by zero is not allowed');
+        Operator::divide(0);
+    }
+
+    public function testDivideByZeroValidator(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [0]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('division', $validator->getDescription());
+    }
+
+    public function testModuloOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'value', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testModuloByZero(): void
+    {
+        $this->expectException(OperatorException::class);
+        $this->expectExceptionMessage('Modulo by zero is not allowed');
+        Operator::modulo(0);
+    }
+
+    public function testModuloByZeroValidator(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'value', [0]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('modulo', $validator->getDescription());
+    }
+
+    public function testModuloNegative(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'value', [-3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerFractional(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [0.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerNegativeExponent(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [-2]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerOverflow(): void
+    {
+        $currentDoc = new Document(['value' => 100]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [10]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would overflow', $validator->getDescription());
+    }
+
+    public function testStringConcat(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'title'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'title', [' World']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringConcatExceedsMaxLength(): void
+    {
+        $currentDoc = new Document(['title' => str_repeat('a', 95)]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'title', size: 100),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'title', [str_repeat('b', 10)]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('exceed maximum length', $validator->getDescription());
+    }
+
+    public function testStringConcatWithinMaxLength(): void
+    {
+        $currentDoc = new Document(['title' => str_repeat('a', 90)]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'title', size: 100),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'title', [str_repeat('b', 10)]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringConcatRequiresStringValue(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'title'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'title', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires a string value', $validator->getDescription());
+    }
+
+    public function testStringConcatNonStringValue(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'title'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'title', [123]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires a string value', $validator->getDescription());
+    }
+
+    public function testStringReplace(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['old', 'new']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringReplaceMultipleOccurrences(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['test', 'demo']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringReplaceValidation(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['only_search']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires exactly 2 string values', $validator->getDescription());
+    }
+
+    public function testStringReplaceWithNonStringValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', [123, 456]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires exactly 2 string values', $validator->getDescription());
+    }
+
+    public function testStringReplaceOnNonStringField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'number'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'number', ['old', 'new']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-string field', $validator->getDescription());
+    }
+
+    public function testToggleBoolean(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::boolean(key: 'active'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'active', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testToggleFromDefault(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::boolean(key: 'active', default: false),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'active', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testToggleOnNonBoolean(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'count', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-boolean field', $validator->getDescription());
+    }
+
+    public function testToggleOnStringField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'name', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-boolean field', $validator->getDescription());
+    }
+
+    public function testDateAddDays(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', [5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateSubDays(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateSubDays, 'date', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateSetNow(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'timestamp'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateSetNow, 'timestamp', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateAtYearBoundaries(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', [365]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::DateSubDays, 'date', [365]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', [-365]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateAddDaysOnNonDateField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'name', [5]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-datetime field', $validator->getDescription());
+    }
+
+    public function testDateAddDaysRequiresIntValue(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires an integer number of days', $validator->getDescription());
+    }
+
+    public function testDateAddDaysNonIntegerValue(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', [3.5]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires an integer number of days', $validator->getDescription());
+    }
+
+    public function testDateSetNowOnNonDateField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateSetNow, 'name', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-datetime field', $validator->getDescription());
+    }
+
+    public function testArrayAppend(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayAppend, 'tags', ['new', 'items']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayAppendViolatesConstraints(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayAppend, 'name', ['item']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayAppendIntegerBounds(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayAppend, 'numbers', [Database::MAX_INT + 1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('array items must be between', $validator->getDescription());
+    }
+
+    public function testArrayPrepend(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayPrepend, 'tags', ['first', 'second']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayPrependOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayPrepend, 'name', ['item']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayInsert(): void
+    {
+        $currentDoc = new Document(['numbers' => [1, 2, 3]]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'numbers', [1, 99]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayInsertAtBoundaries(): void
+    {
+        $currentDoc = new Document(['numbers' => [1, 2, 3]]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ], $currentDoc);
+
+        $opStart = $this->makeOperator(OperatorType::ArrayInsert, 'numbers', [0, 0]);
+        $this->assertTrue($validator->isValid($opStart));
+
+        $opEnd = $this->makeOperator(OperatorType::ArrayInsert, 'numbers', [3, 4]);
+        $this->assertTrue($validator->isValid($opEnd));
+    }
+
+    public function testArrayInsertOutOfBounds(): void
+    {
+        $currentDoc = new Document(['items' => ['a', 'b', 'c']]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'items', [10, 'new']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('index 10 is out of bounds for array of length 3', $validator->getDescription());
+    }
+
+    public function testArrayInsertNegativeIndex(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'items', [-1, 'new']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('index must be a non-negative integer', $validator->getDescription());
+    }
+
+    public function testArrayInsertMissingValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'items', [0]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires exactly 2 values', $validator->getDescription());
+    }
+
+    public function testArrayInsertOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'name', [0, 'val']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayRemove(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayRemove, 'tags', ['unwanted']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayRemoveOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayRemove, 'name', ['val']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayRemoveEmptyValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayRemove, 'tags', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires a value to remove', $validator->getDescription());
+    }
+
+    public function testArrayFilter(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['greaterThan', 5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayFilterNumeric(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $opGt = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['greaterThan', 10]);
+        $this->assertTrue($validator->isValid($opGt));
+
+        $opLt = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['lessThan', 3]);
+        $this->assertTrue($validator->isValid($opLt));
+
+        $opGte = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['greaterThanEqual', 5]);
+        $this->assertTrue($validator->isValid($opGte));
+
+        $opLte = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['lessThanEqual', 5]);
+        $this->assertTrue($validator->isValid($opLte));
+    }
+
+    public function testArrayFilterValidation(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['invalidCondition', 5]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('Invalid array filter condition', $validator->getDescription());
+    }
+
+    public function testArrayFilterOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'name', ['equal', 'test']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayFilterEmptyValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires 1 or 2 values', $validator->getDescription());
+    }
+
+    public function testArrayFilterTooManyValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['greaterThan', 5, 'extra']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires 1 or 2 values', $validator->getDescription());
+    }
+
+    public function testArrayFilterConditionNotString(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', [123, 5]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('condition must be a string', $validator->getDescription());
+    }
+
+    public function testArrayFilterNullConditions(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $opNull = $this->makeOperator(OperatorType::ArrayFilter, 'tags', ['isNull']);
+        $this->assertTrue($validator->isValid($opNull));
+
+        $opNotNull = $this->makeOperator(OperatorType::ArrayFilter, 'tags', ['isNotNull']);
+        $this->assertTrue($validator->isValid($opNotNull));
+    }
+
+    public function testArrayDiff(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayDiff, 'tags', ['remove_me', 'and_me']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayDiffOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayDiff, 'name', ['val']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array attribute', $validator->getDescription());
+    }
+
+    public function testArrayIntersect(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayIntersect, 'items', ['a', 'b', 'c']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayIntersectEmpty(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayIntersect, 'items', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('requires a non-empty array value', $validator->getDescription());
+    }
+
+    public function testArrayIntersectOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayIntersect, 'name', ['val']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array attribute', $validator->getDescription());
+    }
+
+    public function testArrayUnique(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayUnique, 'items', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayUniqueOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayUnique, 'name', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-array field', $validator->getDescription());
+    }
+
+    public function testArrayOperationsOnEmpty(): void
+    {
+        $currentDoc = new Document(['items' => []]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ], $currentDoc);
+
+        $opAppend = $this->makeOperator(OperatorType::ArrayAppend, 'items', ['first']);
+        $this->assertTrue($validator->isValid($opAppend));
+
+        $opPrepend = $this->makeOperator(OperatorType::ArrayPrepend, 'items', ['first']);
+        $this->assertTrue($validator->isValid($opPrepend));
+
+        $opInsert = $this->makeOperator(OperatorType::ArrayInsert, 'items', [0, 'first']);
+        $this->assertTrue($validator->isValid($opInsert));
+
+        $opInsertOOB = $this->makeOperator(OperatorType::ArrayInsert, 'items', [1, 'second']);
+        $this->assertFalse($validator->isValid($opInsertOOB));
+    }
+
+    public function testArrayWithSingleElement(): void
+    {
+        $currentDoc = new Document(['items' => ['only']]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ], $currentDoc);
+
+        $opInsert0 = $this->makeOperator(OperatorType::ArrayInsert, 'items', [0, 'before']);
+        $this->assertTrue($validator->isValid($opInsert0));
+
+        $opInsert1 = $this->makeOperator(OperatorType::ArrayInsert, 'items', [1, 'after']);
+        $this->assertTrue($validator->isValid($opInsert1));
+
+        $opInsertOOB = $this->makeOperator(OperatorType::ArrayInsert, 'items', [2, 'oob']);
+        $this->assertFalse($validator->isValid($opInsertOOB));
+    }
+
+    public function testArrayWithNull(): void
+    {
+        $currentDoc = new Document(['items' => null]);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'items', size: 50, array: true),
+        ], $currentDoc);
+
+        $opAppend = $this->makeOperator(OperatorType::ArrayAppend, 'items', ['first']);
+        $this->assertTrue($validator->isValid($opAppend));
+    }
+
+    public function testIncrementOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [1.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementWithPreciseFloats(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [0.1]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [PHP_FLOAT_EPSILON]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testFloatPrecisionLoss(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [0.000000001]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'score', [1.0000000001]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testSequentialOperators(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::double(key: 'score'),
+            Attribute::string(key: 'name'),
+        ]);
+
+        $op1 = $this->makeOperator(OperatorType::Increment, 'count', [1]);
+        $op2 = $this->makeOperator(OperatorType::Multiply, 'score', [2.0]);
+        $op3 = $this->makeOperator(OperatorType::StringConcat, 'name', [' suffix']);
+
+        $this->assertTrue($validator->isValid($op1));
+        $this->assertTrue($validator->isValid($op2));
+        $this->assertTrue($validator->isValid($op3));
+    }
+
+    public function testComplexScenarios(): void
+    {
+        $currentDoc = new Document([
+            'count' => 50,
+            'tags' => ['a', 'b', 'c'],
+            'name' => 'Hello',
+            'active' => false,
+            'date' => '2023-01-01 00:00:00',
+        ]);
+
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::string(key: 'tags', size: 50, array: true),
+            Attribute::string(key: 'name'),
+            Attribute::boolean(key: 'active'),
+            Attribute::datetime(key: 'date'),
+        ], $currentDoc);
+
+        $this->assertTrue($validator->isValid($this->makeOperator(OperatorType::Increment, 'count', [10])));
+        $this->assertTrue($validator->isValid($this->makeOperator(OperatorType::ArrayAppend, 'tags', ['new'])));
+        $this->assertTrue($validator->isValid($this->makeOperator(OperatorType::StringConcat, 'name', [' World'])));
+        $this->assertTrue($validator->isValid($this->makeOperator(OperatorType::Toggle, 'active', [])));
+        $this->assertTrue($validator->isValid($this->makeOperator(OperatorType::DateAddDays, 'date', [7])));
+    }
+
+    public function testErrorHandling(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'nonexistent', [1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('does not exist', $validator->getDescription());
+    }
+
+    public function testNullValueHandling(): void
+    {
+        $currentDoc = new Document(['count' => null, 'name' => null]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::string(key: 'name', size: 100),
+        ], $currentDoc);
+
+        $opInc = $this->makeOperator(OperatorType::Increment, 'count', [5]);
+        $this->assertTrue($validator->isValid($opInc));
+
+        $opConcat = $this->makeOperator(OperatorType::StringConcat, 'name', ['hello']);
+        $this->assertTrue($validator->isValid($opConcat));
+    }
+
+    public function testValueLimits(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'counter'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'counter', [5, 50]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'counter', [5, 0]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'counter', [2, 100]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Power, 'counter', [3, 1000]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testValueLimitsNonNumeric(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'counter'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'counter', [5, 'not_a_number']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('max/min limit must be numeric', $validator->getDescription());
+    }
+
+    public function testAttributeConstraints(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $opNumericOnArray = $this->makeOperator(OperatorType::Increment, 'tags', [1]);
+        $this->assertFalse($validator->isValid($opNumericOnArray));
+
+        $opArrayOnNumeric = $this->makeOperator(OperatorType::ArrayAppend, 'score', ['val']);
+        $this->assertFalse($validator->isValid($opArrayOnNumeric));
+    }
+
+    public function testEmptyStrings(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $opConcat = $this->makeOperator(OperatorType::StringConcat, 'text', ['']);
+        $this->assertTrue($validator->isValid($opConcat));
+
+        $opReplace = $this->makeOperator(OperatorType::StringReplace, 'text', ['old', '']);
+        $this->assertTrue($validator->isValid($opReplace));
+    }
+
+    public function testExtremeIntegerValues(): void
+    {
+        $currentDoc = new Document(['value' => 0]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $opMaxInc = $this->makeOperator(OperatorType::Increment, 'value', [Database::MAX_INT]);
+        $this->assertTrue($validator->isValid($opMaxInc));
+
+        $currentDoc2 = new Document(['value' => 1]);
+        $validator2 = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc2);
+
+        $opOverflow = $this->makeOperator(OperatorType::Increment, 'value', [Database::MAX_INT]);
+        $this->assertFalse($validator2->isValid($opOverflow));
+    }
+
+    public function testUnicodeCharacters(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'text', [' mundo']);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['hello', 'hola']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testVeryLongStrings(): void
+    {
+        $currentDoc = new Document(['text' => '']);
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text', size: 100),
+        ], $currentDoc);
+
+        $opFits = $this->makeOperator(OperatorType::StringConcat, 'text', [str_repeat('x', 100)]);
+        $this->assertTrue($validator->isValid($opFits));
+
+        $opExceeds = $this->makeOperator(OperatorType::StringConcat, 'text', [str_repeat('x', 101)]);
+        $this->assertFalse($validator->isValid($opExceeds));
+        $this->assertStringContainsString('exceed maximum length', $validator->getDescription());
+    }
+
+    public function testZeroValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'count', [0]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'count', [0]);
+        $this->assertTrue($validator->isValid($op));
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'score', [0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testBatchOperators(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::double(key: 'score'),
+            Attribute::string(key: 'tags', size: 50, array: true),
+            Attribute::string(key: 'title'),
+            Attribute::boolean(key: 'active'),
+            Attribute::datetime(key: 'date'),
+        ]);
+
+        $operators = [
+            $this->makeOperator(OperatorType::Increment, 'count', [5]),
+            $this->makeOperator(OperatorType::Multiply, 'score', [2.0]),
+            $this->makeOperator(OperatorType::ArrayAppend, 'tags', ['new']),
+            $this->makeOperator(OperatorType::StringConcat, 'title', [' Updated']),
+            $this->makeOperator(OperatorType::Toggle, 'active', []),
+            $this->makeOperator(OperatorType::DateSetNow, 'date', []),
+        ];
+
+        foreach ($operators as $op) {
+            $this->assertTrue($validator->isValid($op), "Failed for operator: {$op->getMethod()->value} on {$op->getAttribute()}");
+        }
+    }
+
+    public function testIncrementOnTextAttribute(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'text_field', size: 100),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'text_field', [1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString("non-numeric field 'text_field'", $validator->getDescription());
+    }
+
+    public function testIncrementOnArrayAttribute(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'tags', [1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-numeric field', $validator->getDescription());
+    }
+
+    public function testIncrementOnBooleanAttribute(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::boolean(key: 'active'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'active', [1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-numeric field', $validator->getDescription());
+    }
+
+    public function testNumericOperatorNonNumericValue(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'count', ['not_a_number']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('value must be numeric', $validator->getDescription());
+    }
+
+    public function testNumericOperatorEmptyValues(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'count', []);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('value must be numeric', $validator->getDescription());
+    }
+
+    public function testStringConcatOnNonStringField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'count', [' suffix']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-string field', $validator->getDescription());
+    }
+
+    public function testStringConcatOnArrayField(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringConcat, 'tags', [' suffix']);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('non-string field', $validator->getDescription());
+    }
+
+    public function testArrayInsertIntegerBounds(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'numbers', array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayInsert, 'numbers', [0, Database::MAX_INT + 1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('array items must be between', $validator->getDescription());
+    }
+
+    public function testDecrementUnderflow(): void
+    {
+        $currentDoc = new Document(['count' => Database::MIN_INT + 2]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'count', [5]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('would underflow', $validator->getDescription());
+    }
+
+    public function testModuloOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'score', [3.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerWithMaxLimit(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [2, 1000]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDivideWithMinLimit(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'value'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [2.0, 1.0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementWithMaxCap(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'counter'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'counter', [100, 50]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDecrementWithMinCap(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'counter'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'counter', [100, 0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testOperatorOnNonexistentAttribute(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'nonexistent', [1]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString("'nonexistent' does not exist", $validator->getDescription());
+    }
+
+    public function testAllNumericOperatorsOnString(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $numericTypes = [
+            OperatorType::Increment,
+            OperatorType::Decrement,
+            OperatorType::Multiply,
+            OperatorType::Divide,
+            OperatorType::Modulo,
+            OperatorType::Power,
+        ];
+
+        foreach ($numericTypes as $type) {
+            $op = $this->makeOperator($type, 'name', [1]);
+            $this->assertFalse($validator->isValid($op), "Expected {$type->value} to fail on string field");
+            $this->assertStringContainsString('non-numeric field', $validator->getDescription());
+        }
+    }
+
+    public function testAllArrayOperatorsOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'name'),
+        ]);
+
+        $opAppend = $this->makeOperator(OperatorType::ArrayAppend, 'name', ['val']);
+        $this->assertFalse($validator->isValid($opAppend));
+
+        $opPrepend = $this->makeOperator(OperatorType::ArrayPrepend, 'name', ['val']);
+        $this->assertFalse($validator->isValid($opPrepend));
+
+        $opInsert = $this->makeOperator(OperatorType::ArrayInsert, 'name', [0, 'val']);
+        $this->assertFalse($validator->isValid($opInsert));
+
+        $opRemove = $this->makeOperator(OperatorType::ArrayRemove, 'name', ['val']);
+        $this->assertFalse($validator->isValid($opRemove));
+
+        $opUnique = $this->makeOperator(OperatorType::ArrayUnique, 'name', []);
+        $this->assertFalse($validator->isValid($opUnique));
+
+        $opDiff = $this->makeOperator(OperatorType::ArrayDiff, 'name', ['val']);
+        $this->assertFalse($validator->isValid($opDiff));
+
+        $opIntersect = $this->makeOperator(OperatorType::ArrayIntersect, 'name', ['val']);
+        $this->assertFalse($validator->isValid($opIntersect));
+
+        $opFilter = $this->makeOperator(OperatorType::ArrayFilter, 'name', ['equal', 'val']);
+        $this->assertFalse($validator->isValid($opFilter));
+    }
+
+    public function testDateOperatorsOnNonDateFields(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::string(key: 'name'),
+            Attribute::boolean(key: 'active'),
+        ]);
+
+        foreach (['count', 'name', 'active'] as $field) {
+            $op = $this->makeOperator(OperatorType::DateAddDays, $field, [5]);
+            $this->assertFalse($validator->isValid($op));
+            $this->assertStringContainsString('non-datetime field', $validator->getDescription());
+
+            $op = $this->makeOperator(OperatorType::DateSubDays, $field, [5]);
+            $this->assertFalse($validator->isValid($op));
+            $this->assertStringContainsString('non-datetime field', $validator->getDescription());
+
+            $op = $this->makeOperator(OperatorType::DateSetNow, $field, []);
+            $this->assertFalse($validator->isValid($op));
+            $this->assertStringContainsString('non-datetime field', $validator->getDescription());
+        }
+    }
+
+    public function testExtractOperatorsAndValidate(): void
+    {
+        $data = [
+            'count' => Operator::increment(5),
+            'tags' => Operator::arrayAppend(['new']),
+            'name' => 'Regular value',
+        ];
+
+        $result = Operator::extractOperators($data);
+        $this->assertCount(2, $result['operators']);
+        $this->assertCount(1, $result['updates']);
+
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'count'),
+            Attribute::string(key: 'tags', size: 50, array: true),
+            Attribute::string(key: 'name'),
+        ]);
+
+        foreach ($result['operators'] as $op) {
+            $this->assertTrue($validator->isValid($op));
+        }
+    }
+
+    public function testOperatorTypeClassificationMethods(): void
+    {
+        $this->assertTrue(OperatorType::Increment->isNumeric());
+        $this->assertTrue(OperatorType::Decrement->isNumeric());
+        $this->assertTrue(OperatorType::Multiply->isNumeric());
+        $this->assertTrue(OperatorType::Divide->isNumeric());
+        $this->assertTrue(OperatorType::Modulo->isNumeric());
+        $this->assertTrue(OperatorType::Power->isNumeric());
+
+        $this->assertTrue(OperatorType::ArrayAppend->isArray());
+        $this->assertTrue(OperatorType::ArrayPrepend->isArray());
+        $this->assertTrue(OperatorType::ArrayInsert->isArray());
+        $this->assertTrue(OperatorType::ArrayRemove->isArray());
+        $this->assertTrue(OperatorType::ArrayUnique->isArray());
+        $this->assertTrue(OperatorType::ArrayIntersect->isArray());
+        $this->assertTrue(OperatorType::ArrayDiff->isArray());
+        $this->assertTrue(OperatorType::ArrayFilter->isArray());
+
+        $this->assertTrue(OperatorType::StringConcat->isString());
+        $this->assertTrue(OperatorType::StringReplace->isString());
+
+        $this->assertTrue(OperatorType::Toggle->isBoolean());
+
+        $this->assertTrue(OperatorType::DateAddDays->isDate());
+        $this->assertTrue(OperatorType::DateSubDays->isDate());
+        $this->assertTrue(OperatorType::DateSetNow->isDate());
+
+        $this->assertFalse(OperatorType::Increment->isArray());
+        $this->assertFalse(OperatorType::ArrayAppend->isNumeric());
+        $this->assertFalse(OperatorType::StringConcat->isNumeric());
+        $this->assertFalse(OperatorType::Toggle->isNumeric());
+        $this->assertFalse(OperatorType::DateAddDays->isNumeric());
+    }
+
+    public function testOperatorHelperMethods(): void
+    {
+        $inc = Operator::increment(5, 100);
+        $this->assertEquals(OperatorType::Increment, $inc->getMethod());
+        $this->assertEquals([5, 100], $inc->getValues());
+
+        $dec = Operator::decrement(3, 0);
+        $this->assertEquals(OperatorType::Decrement, $dec->getMethod());
+        $this->assertEquals([3, 0], $dec->getValues());
+
+        $mul = Operator::multiply(2, 50);
+        $this->assertEquals(OperatorType::Multiply, $mul->getMethod());
+        $this->assertEquals([2, 50], $mul->getValues());
+
+        $div = Operator::divide(4, 1);
+        $this->assertEquals(OperatorType::Divide, $div->getMethod());
+        $this->assertEquals([4, 1], $div->getValues());
+
+        $mod = Operator::modulo(7);
+        $this->assertEquals(OperatorType::Modulo, $mod->getMethod());
+        $this->assertEquals([7], $mod->getValues());
+
+        $pow = Operator::power(3, 999);
+        $this->assertEquals(OperatorType::Power, $pow->getMethod());
+        $this->assertEquals([3, 999], $pow->getValues());
+    }
+
+    public function testArrayFilterEqualCondition(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'tags', ['equal', 'active']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayFilterNotEqualCondition(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::string(key: 'tags', size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'tags', ['notEqual', 'inactive']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testMultiplyByZero(): void
+    {
+        $currentDoc = new Document(['value' => 42]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'value', [0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDecrementFromZero(): void
+    {
+        $currentDoc = new Document(['value' => 0]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'value', [1]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementFromMaxMinusOne(): void
+    {
+        $currentDoc = new Document(['value' => Database::MAX_INT - 1]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'value', [1]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDecrementFromMinPlusOne(): void
+    {
+        $currentDoc = new Document(['value' => Database::MIN_INT + 1]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'value', [1]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testFloatOperatorsSkipOverflowCheck(): void
+    {
+        $currentDoc = new Document(['score' => PHP_FLOAT_MAX / 2]);
+        $validator = $this->makeValidator([
+            Attribute::double(key: 'score'),
+        ], $currentDoc);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [PHP_FLOAT_MAX / 2]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIntegerOverflowWithMaxCap(): void
+    {
+        $currentDoc = new Document(['value' => Database::MAX_INT - 5]);
+        $validator = $this->makeValidator([
+            Attribute::integer(key: 'value'),
+        ], $currentDoc);
+
+        $opWithCap = $this->makeOperator(OperatorType::Increment, 'value', [100, Database::MAX_INT]);
+        $this->assertTrue($validator->isValid($opWithCap));
+
+        $opWithoutCap = $this->makeOperator(OperatorType::Increment, 'value', [100]);
+        $this->assertFalse($validator->isValid($opWithoutCap));
+    }
+
+    public function testNumericOperatorsAcceptEveryNumericColumnType(): void
+    {
+        foreach ([
+            ColumnType::Integer,
+            ColumnType::Float,
+            ColumnType::Double,
+            ColumnType::BigInteger,
+            ColumnType::BigSerial,
+        ] as $type) {
+            $validator = $this->makeValidator([
+                new Attribute(key: 'value', type: $type),
+            ]);
+            $operator = $this->makeOperator(OperatorType::Increment, 'value', [1]);
+
+            $this->assertTrue($validator->isValid($operator), $type->value);
+        }
+    }
+
+    public function testNumericOperatorAcceptsLegacyBigIntegerMetadata(): void
+    {
+        $collection = $this->makeCollection([]);
+        $collection->setAttribute('attributes', [new Document([
+            '$id' => 'value',
+            'key' => 'value',
+            'type' => Attribute::LEGACY_BIG_INTEGER,
+            'signed' => true,
+            'array' => false,
+        ])]);
+        $validator = new OperatorValidator($collection, new Document(['value' => PHP_INT_MAX - 1]));
+
+        $this->assertTrue($validator->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+    }
+
+    public function testBigIntegerOperatorRejectsOverflow(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::bigInteger(key: 'value'),
+        ], new Document(['value' => PHP_INT_MAX]));
+
+        $this->assertFalse($validator->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+        $this->assertStringContainsString('would overflow', $validator->getDescription());
+    }
+
+    public function testUnsignedBigIntegerOperatorRejectsUnderflow(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::bigInteger(key: 'value', signed: false),
+        ], new Document(['value' => 0]));
+
+        $this->assertFalse($validator->isValid(
+            $this->makeOperator(OperatorType::Decrement, 'value', [1])
+        ));
+        $this->assertStringContainsString('would underflow', $validator->getDescription());
+    }
+
+    public function testUnsignedBigIntegerOperatorCrossesPhpIntegerBoundary(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::bigInteger(key: 'value', signed: false),
+        ], new Document(['value' => PHP_INT_MAX]));
+
+        $this->assertTrue($validator->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+    }
+
+    public function testUnsignedBigIntegerOperatorAcceptsAndProtectsExactMaximum(): void
+    {
+        $attribute = Attribute::bigInteger(key: 'value', signed: false);
+        $atBoundary = $this->makeValidator([$attribute], new Document(['value' => '18446744073709551614']));
+        $overflow = $this->makeValidator([$attribute], new Document(['value' => '18446744073709551615']));
+
+        $this->assertTrue($atBoundary->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+        $this->assertFalse($overflow->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+        $this->assertStringContainsString('18446744073709551615', $overflow->getDescription());
+    }
+
+    public function testUnsignedBigIntegerOperatorRejectsUnsupportedAdapter(): void
+    {
+        $validator = new OperatorValidator(
+            $this->makeCollection([
+                Attribute::bigInteger(key: 'value', signed: false),
+            ]),
+            new Document(['value' => 1]),
+            false,
+        );
+
+        $this->assertFalse($validator->isValid(
+            $this->makeOperator(OperatorType::Increment, 'value', [1])
+        ));
+        $this->assertStringContainsString('not supported', $validator->getDescription());
+    }
+
+    public function testUnsignedBigIntegerArrayOperatorUsesExactBounds(): void
+    {
+        $validator = $this->makeValidator([
+            Attribute::bigInteger(key: 'values', signed: false, array: true),
+        ]);
+
+        $this->assertTrue($validator->isValid(
+            $this->makeOperator(OperatorType::ArrayAppend, 'values', [['18446744073709551615']])
+        ));
+        $this->assertFalse($validator->isValid(
+            $this->makeOperator(OperatorType::ArrayAppend, 'values', [['18446744073709551616']])
+        ));
+    }
+}
diff --git a/tests/unit/OperatorTest.php b/tests/unit/OperatorTest.php
index 0c07a6d032..d960b77129 100644
--- a/tests/unit/OperatorTest.php
+++ b/tests/unit/OperatorTest.php
@@ -5,39 +5,40 @@
 use PHPUnit\Framework\TestCase;
 use Utopia\Database\Exception\Operator as OperatorException;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
 
 class OperatorTest extends TestCase
 {
-    public function testCreate(): void
+    public function test_create(): void
     {
         // Test basic construction
-        $operator = new Operator(Operator::TYPE_INCREMENT, 'count', [1]);
+        $operator = new Operator(OperatorType::Increment, 'count', [1]);
 
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operator->getMethod());
         $this->assertEquals('count', $operator->getAttribute());
         $this->assertEquals([1], $operator->getValues());
         $this->assertEquals(1, $operator->getValue());
 
         // Test with different types
-        $operator = new Operator(Operator::TYPE_ARRAY_APPEND, 'tags', ['php', 'database']);
+        $operator = new Operator(OperatorType::ArrayAppend, 'tags', ['php', 'database']);
 
-        $this->assertEquals(Operator::TYPE_ARRAY_APPEND, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayAppend, $operator->getMethod());
         $this->assertEquals('tags', $operator->getAttribute());
         $this->assertEquals(['php', 'database'], $operator->getValues());
         $this->assertEquals('php', $operator->getValue());
     }
 
-    public function testHelperMethods(): void
+    public function test_helper_methods(): void
     {
         // Test increment helper
         $operator = Operator::increment(5);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute()); // Initially empty
         $this->assertEquals([5], $operator->getValues());
 
         // Test decrement helper
         $operator = Operator::decrement(1);
-        $this->assertEquals(Operator::TYPE_DECREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Decrement, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute()); // Initially empty
         $this->assertEquals([1], $operator->getValues());
 
@@ -47,81 +48,81 @@ public function testHelperMethods(): void
 
         // Test string helpers
         $operator = Operator::stringConcat(' - Updated');
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([' - Updated'], $operator->getValues());
 
         $operator = Operator::stringReplace('old', 'new');
-        $this->assertEquals(Operator::TYPE_STRING_REPLACE, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringReplace, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['old', 'new'], $operator->getValues());
 
         // Test math helpers
         $operator = Operator::multiply(2, 1000);
-        $this->assertEquals(Operator::TYPE_MULTIPLY, $operator->getMethod());
+        $this->assertEquals(OperatorType::Multiply, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([2, 1000], $operator->getValues());
 
         $operator = Operator::divide(2, 1);
-        $this->assertEquals(Operator::TYPE_DIVIDE, $operator->getMethod());
+        $this->assertEquals(OperatorType::Divide, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([2, 1], $operator->getValues());
 
         // Test boolean helper
         $operator = Operator::toggle();
-        $this->assertEquals(Operator::TYPE_TOGGLE, $operator->getMethod());
+        $this->assertEquals(OperatorType::Toggle, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([], $operator->getValues());
 
         $operator = Operator::dateSetNow();
-        $this->assertEquals(Operator::TYPE_DATE_SET_NOW, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateSetNow, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([], $operator->getValues());
 
         // Test concat helper
         $operator = Operator::stringConcat(' - Updated');
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([' - Updated'], $operator->getValues());
 
         // Test modulo and power operators
         $operator = Operator::modulo(3);
-        $this->assertEquals(Operator::TYPE_MODULO, $operator->getMethod());
+        $this->assertEquals(OperatorType::Modulo, $operator->getMethod());
         $this->assertEquals([3], $operator->getValues());
 
         $operator = Operator::power(2, 1000);
-        $this->assertEquals(Operator::TYPE_POWER, $operator->getMethod());
+        $this->assertEquals(OperatorType::Power, $operator->getMethod());
         $this->assertEquals([2, 1000], $operator->getValues());
 
         // Test new array helper methods
         $operator = Operator::arrayAppend(['new', 'values']);
-        $this->assertEquals(Operator::TYPE_ARRAY_APPEND, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayAppend, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['new', 'values'], $operator->getValues());
 
         $operator = Operator::arrayPrepend(['first', 'second']);
-        $this->assertEquals(Operator::TYPE_ARRAY_PREPEND, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayPrepend, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['first', 'second'], $operator->getValues());
 
         $operator = Operator::arrayInsert(2, 'inserted');
-        $this->assertEquals(Operator::TYPE_ARRAY_INSERT, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayInsert, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([2, 'inserted'], $operator->getValues());
 
         $operator = Operator::arrayRemove('unwanted');
-        $this->assertEquals(Operator::TYPE_ARRAY_REMOVE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayRemove, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['unwanted'], $operator->getValues());
     }
 
-    public function testSetters(): void
+    public function test_setters(): void
     {
-        $operator = new Operator(Operator::TYPE_INCREMENT, 'test', [1]);
+        $operator = new Operator(OperatorType::Increment, 'test', [1]);
 
         // Test setMethod
-        $operator->setMethod(Operator::TYPE_DECREMENT);
-        $this->assertEquals(Operator::TYPE_DECREMENT, $operator->getMethod());
+        $operator->setMethod(OperatorType::Decrement);
+        $this->assertEquals(OperatorType::Decrement, $operator->getMethod());
 
         // Test setAttribute
         $operator->setAttribute('newAttribute');
@@ -137,7 +138,7 @@ public function testSetters(): void
         $this->assertEquals(50, $operator->getValue());
     }
 
-    public function testTypeMethods(): void
+    public function test_type_methods(): void
     {
         // Test numeric operations
         $incrementOp = Operator::increment(1);
@@ -165,7 +166,6 @@ public function testTypeMethods(): void
         $this->assertFalse($toggleOp->isArrayOperation());
         $this->assertTrue($toggleOp->isBooleanOperation());
 
-
         // Test date operations
         $dateSetNowOp = Operator::dateSetNow();
         $this->assertFalse($dateSetNowOp->isNumericOperation());
@@ -190,26 +190,26 @@ public function testTypeMethods(): void
         $this->assertTrue($arrayRemoveOp->isArrayOperation());
     }
 
-    public function testIsMethod(): void
+    public function test_is_method(): void
     {
         // Test valid methods
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_INCREMENT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_DECREMENT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_MULTIPLY));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_DIVIDE));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_STRING_CONCAT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_STRING_REPLACE));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_TOGGLE));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_STRING_CONCAT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_DATE_SET_NOW));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_MODULO));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_POWER));
+        $this->assertTrue(Operator::isMethod(OperatorType::Increment->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Decrement->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Multiply->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Divide->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::StringConcat->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::StringReplace->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Toggle->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::StringConcat->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::DateSetNow->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Modulo->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::Power->value));
 
         // Test new array methods
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_APPEND));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_PREPEND));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_INSERT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_REMOVE));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayAppend->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayPrepend->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayInsert->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayRemove->value));
 
         // Test invalid methods
         $this->assertFalse(Operator::isMethod('invalid'));
@@ -219,7 +219,7 @@ public function testIsMethod(): void
         $this->assertFalse(Operator::isMethod('insert')); // Old method should be false
     }
 
-    public function testIsOperator(): void
+    public function test_is_operator(): void
     {
         $operator = Operator::increment(1);
         $this->assertTrue(Operator::isOperator($operator));
@@ -230,29 +230,22 @@ public function testIsOperator(): void
         $this->assertFalse(Operator::isOperator(null));
     }
 
-    public function testExtractOperators(): void
+    public function test_extract_operators(): void
     {
         $data = [
             'name' => 'John',
             'count' => Operator::increment(5),
             'tags' => Operator::arrayAppend(['new']),
-            'age' => 30
+            'age' => 30,
         ];
 
         $result = Operator::extractOperators($data);
 
-        $this->assertArrayHasKey('operators', $result);
-        $this->assertArrayHasKey('updates', $result);
-
         $operators = $result['operators'];
         $updates = $result['updates'];
 
-        // Check operators
         $this->assertCount(2, $operators);
-        $this->assertInstanceOf(Operator::class, $operators['count']);
-        $this->assertInstanceOf(Operator::class, $operators['tags']);
 
-        // Check that attributes are set from document keys
         $this->assertEquals('count', $operators['count']->getAttribute());
         $this->assertEquals('tags', $operators['tags']->getAttribute());
 
@@ -260,7 +253,7 @@ public function testExtractOperators(): void
         $this->assertEquals(['name' => 'John', 'age' => 30], $updates);
     }
 
-    public function testSerialization(): void
+    public function test_serialization(): void
     {
         $operator = Operator::increment(10);
         $operator->setAttribute('score'); // Simulate setting attribute
@@ -268,9 +261,9 @@ public function testSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_INCREMENT,
+            'method' => OperatorType::Increment->value,
             'attribute' => 'score',
-            'values' => [10]
+            'values' => [10],
         ];
         $this->assertEquals($expected, $array);
 
@@ -281,17 +274,17 @@ public function testSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testParsing(): void
+    public function test_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_INCREMENT,
+            'method' => OperatorType::Increment->value,
             'attribute' => 'score',
-            'values' => [5]
+            'values' => [5],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operator->getMethod());
         $this->assertEquals('score', $operator->getAttribute());
         $this->assertEquals([5], $operator->getValues());
 
@@ -299,15 +292,15 @@ public function testParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operator->getMethod());
         $this->assertEquals('score', $operator->getAttribute());
         $this->assertEquals([5], $operator->getValues());
     }
 
-    public function testParseOperators(): void
+    public function test_parse_operators(): void
     {
-        $json1 = json_encode(['method' => Operator::TYPE_INCREMENT, 'attribute' => 'count', 'values' => [1]]);
-        $json2 = json_encode(['method' => Operator::TYPE_ARRAY_APPEND, 'attribute' => 'tags', 'values' => ['new']]);
+        $json1 = json_encode(['method' => OperatorType::Increment->value, 'attribute' => 'count', 'values' => [1]]);
+        $json2 = json_encode(['method' => OperatorType::ArrayAppend->value, 'attribute' => 'tags', 'values' => ['new']]);
 
         $this->assertIsString($json1);
         $this->assertIsString($json2);
@@ -316,13 +309,11 @@ public function testParseOperators(): void
 
         $parsed = Operator::parseOperators($operators);
         $this->assertCount(2, $parsed);
-        $this->assertInstanceOf(Operator::class, $parsed[0]);
-        $this->assertInstanceOf(Operator::class, $parsed[1]);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $parsed[0]->getMethod());
-        $this->assertEquals(Operator::TYPE_ARRAY_APPEND, $parsed[1]->getMethod());
+        $this->assertEquals(OperatorType::Increment, $parsed[0]->getMethod());
+        $this->assertEquals(OperatorType::ArrayAppend, $parsed[1]->getMethod());
     }
 
-    public function testClone(): void
+    public function test_clone(): void
     {
         $operator1 = Operator::increment(5);
         $operator2 = clone $operator1;
@@ -332,39 +323,39 @@ public function testClone(): void
         $this->assertEquals($operator1->getValues(), $operator2->getValues());
 
         // Ensure they are different objects
-        $operator2->setMethod(Operator::TYPE_DECREMENT);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator1->getMethod());
-        $this->assertEquals(Operator::TYPE_DECREMENT, $operator2->getMethod());
+        $operator2->setMethod(OperatorType::Decrement);
+        $this->assertEquals(OperatorType::Increment, $operator1->getMethod());
+        $this->assertEquals(OperatorType::Decrement, $operator2->getMethod());
     }
 
-    public function testGetValueWithDefault(): void
+    public function test_get_value_with_default(): void
     {
         $operator = Operator::increment(5);
         $this->assertEquals(5, $operator->getValue());
         $this->assertEquals(5, $operator->getValue('default'));
 
-        $emptyOperator = new Operator(Operator::TYPE_INCREMENT, 'count', []);
+        $emptyOperator = new Operator(OperatorType::Increment, 'count', []);
         $this->assertEquals('default', $emptyOperator->getValue('default'));
         $this->assertNull($emptyOperator->getValue());
     }
 
     // Exception tests
 
-    public function testParseInvalidJson(): void
+    public function test_parse_invalid_json(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator');
         Operator::parse('invalid json');
     }
 
-    public function testParseNonArray(): void
+    public function test_parse_non_array(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator. Must be an array');
         Operator::parse('"string"');
     }
 
-    public function testParseInvalidMethod(): void
+    public function test_parse_invalid_method(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator method. Must be a string');
@@ -372,7 +363,7 @@ public function testParseInvalidMethod(): void
         Operator::parseOperator($array);
     }
 
-    public function testParseUnsupportedMethod(): void
+    public function test_parse_unsupported_method(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator method: invalid');
@@ -380,26 +371,26 @@ public function testParseUnsupportedMethod(): void
         Operator::parseOperator($array);
     }
 
-    public function testParseInvalidAttribute(): void
+    public function test_parse_invalid_attribute(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator attribute. Must be a string');
-        $array = ['method' => Operator::TYPE_INCREMENT, 'attribute' => 123, 'values' => []];
+        $array = ['method' => OperatorType::Increment->value, 'attribute' => 123, 'values' => []];
         Operator::parseOperator($array);
     }
 
-    public function testParseInvalidValues(): void
+    public function test_parse_invalid_values(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Invalid operator values. Must be an array');
-        $array = ['method' => Operator::TYPE_INCREMENT, 'attribute' => 'test', 'values' => 'not array'];
+        $array = ['method' => OperatorType::Increment->value, 'attribute' => 'test', 'values' => 'not array'];
         Operator::parseOperator($array);
     }
 
-    public function testToStringInvalidJson(): void
+    public function test_to_string_invalid_json(): void
     {
         // Create an operator with values that can't be JSON encoded
-        $operator = new Operator(Operator::TYPE_INCREMENT, 'test', []);
+        $operator = new Operator(OperatorType::Increment, 'test', []);
         $operator->setValues([fopen('php://memory', 'r')]); // Resource can't be JSON encoded
 
         $this->expectException(OperatorException::class);
@@ -409,11 +400,11 @@ public function testToStringInvalidJson(): void
 
     // New functionality tests
 
-    public function testIncrementWithMax(): void
+    public function test_increment_with_max(): void
     {
         // Test increment with max limit
         $operator = Operator::increment(5, 10);
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operator->getMethod());
         $this->assertEquals([5, 10], $operator->getValues());
 
         // Test increment without max (should be same as original behavior)
@@ -421,11 +412,11 @@ public function testIncrementWithMax(): void
         $this->assertEquals([5], $operator->getValues());
     }
 
-    public function testDecrementWithMin(): void
+    public function test_decrement_with_min(): void
     {
         // Test decrement with min limit
         $operator = Operator::decrement(3, 0);
-        $this->assertEquals(Operator::TYPE_DECREMENT, $operator->getMethod());
+        $this->assertEquals(OperatorType::Decrement, $operator->getMethod());
         $this->assertEquals([3, 0], $operator->getValues());
 
         // Test decrement without min (should be same as original behavior)
@@ -433,15 +424,15 @@ public function testDecrementWithMin(): void
         $this->assertEquals([3], $operator->getValues());
     }
 
-    public function testArrayRemove(): void
+    public function test_array_remove(): void
     {
         $operator = Operator::arrayRemove('spam');
-        $this->assertEquals(Operator::TYPE_ARRAY_REMOVE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayRemove, $operator->getMethod());
         $this->assertEquals(['spam'], $operator->getValues());
         $this->assertEquals('spam', $operator->getValue());
     }
 
-    public function testExtractOperatorsWithNewMethods(): void
+    public function test_extract_operators_with_new_methods(): void
     {
         $data = [
             'name' => 'John',
@@ -460,7 +451,7 @@ public function testExtractOperatorsWithNewMethods(): void
             'title_prefix' => Operator::stringConcat(' - Updated'),
             'views_modulo' => Operator::modulo(3),
             'score_power' => Operator::power(2, 1000),
-            'age' => 30
+            'age' => 30,
         ];
 
         $result = Operator::extractOperators($data);
@@ -471,33 +462,30 @@ public function testExtractOperatorsWithNewMethods(): void
         // Check operators count (all fields except 'name' and 'age')
         $this->assertCount(15, $operators);
 
-        // Check that array methods are properly extracted
-        $this->assertInstanceOf(Operator::class, $operators['tags']);
         $this->assertEquals('tags', $operators['tags']->getAttribute());
-        $this->assertEquals(Operator::TYPE_ARRAY_APPEND, $operators['tags']->getMethod());
+        $this->assertEquals(OperatorType::ArrayAppend, $operators['tags']->getMethod());
 
-        $this->assertInstanceOf(Operator::class, $operators['blacklist']);
         $this->assertEquals('blacklist', $operators['blacklist']->getAttribute());
-        $this->assertEquals(Operator::TYPE_ARRAY_REMOVE, $operators['blacklist']->getMethod());
+        $this->assertEquals(OperatorType::ArrayRemove, $operators['blacklist']->getMethod());
 
         // Check string operators
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operators['title']->getMethod());
-        $this->assertEquals(Operator::TYPE_STRING_REPLACE, $operators['content']->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operators['title']->getMethod());
+        $this->assertEquals(OperatorType::StringReplace, $operators['content']->getMethod());
 
         // Check math operators
-        $this->assertEquals(Operator::TYPE_MULTIPLY, $operators['views']->getMethod());
-        $this->assertEquals(Operator::TYPE_DIVIDE, $operators['rating']->getMethod());
+        $this->assertEquals(OperatorType::Multiply, $operators['views']->getMethod());
+        $this->assertEquals(OperatorType::Divide, $operators['rating']->getMethod());
 
         // Check boolean operator
-        $this->assertEquals(Operator::TYPE_TOGGLE, $operators['featured']->getMethod());
+        $this->assertEquals(OperatorType::Toggle, $operators['featured']->getMethod());
 
         // Check new operators
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operators['title_prefix']->getMethod());
-        $this->assertEquals(Operator::TYPE_MODULO, $operators['views_modulo']->getMethod());
-        $this->assertEquals(Operator::TYPE_POWER, $operators['score_power']->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operators['title_prefix']->getMethod());
+        $this->assertEquals(OperatorType::Modulo, $operators['views_modulo']->getMethod());
+        $this->assertEquals(OperatorType::Power, $operators['score_power']->getMethod());
 
         // Check date operator
-        $this->assertEquals(Operator::TYPE_DATE_SET_NOW, $operators['last_modified']->getMethod());
+        $this->assertEquals(OperatorType::DateSetNow, $operators['last_modified']->getMethod());
 
         // Check that max/min values are preserved
         $this->assertEquals([5, 100], $operators['count']->getValues());
@@ -507,26 +495,25 @@ public function testExtractOperatorsWithNewMethods(): void
         $this->assertEquals(['name' => 'John', 'age' => 30], $updates);
     }
 
-
-    public function testParsingWithNewConstants(): void
+    public function test_parsing_with_new_constants(): void
     {
         // Test parsing new array methods
         $arrayRemove = [
-            'method' => Operator::TYPE_ARRAY_REMOVE,
+            'method' => OperatorType::ArrayRemove->value,
             'attribute' => 'blacklist',
-            'values' => ['spam']
+            'values' => ['spam'],
         ];
 
         $operator = Operator::parseOperator($arrayRemove);
-        $this->assertEquals(Operator::TYPE_ARRAY_REMOVE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayRemove, $operator->getMethod());
         $this->assertEquals('blacklist', $operator->getAttribute());
         $this->assertEquals(['spam'], $operator->getValues());
 
         // Test parsing increment with max
         $incrementWithMax = [
-            'method' => Operator::TYPE_INCREMENT,
+            'method' => OperatorType::Increment->value,
             'attribute' => 'score',
-            'values' => [1, 10]
+            'values' => [1, 10],
         ];
 
         $operator = Operator::parseOperator($incrementWithMax);
@@ -535,7 +522,7 @@ public function testParsingWithNewConstants(): void
 
     // Edge case tests
 
-    public function testIncrementMaxLimitEdgeCases(): void
+    public function test_increment_max_limit_edge_cases(): void
     {
         // Test that max limit is properly stored
         $operator = Operator::increment(5, 10);
@@ -556,7 +543,7 @@ public function testIncrementMaxLimitEdgeCases(): void
         $this->assertEquals(-5, $values[1]);
     }
 
-    public function testDecrementMinLimitEdgeCases(): void
+    public function test_decrement_min_limit_edge_cases(): void
     {
         // Test that min limit is properly stored
         $operator = Operator::decrement(3, 0);
@@ -577,7 +564,7 @@ public function testDecrementMinLimitEdgeCases(): void
         $this->assertEquals(-10, $values[1]);
     }
 
-    public function testArrayRemoveEdgeCases(): void
+    public function test_array_remove_edge_cases(): void
     {
         // Test removing various types of values
         $operator = Operator::arrayRemove('string');
@@ -597,7 +584,7 @@ public function testArrayRemoveEdgeCases(): void
         $this->assertEquals(['nested'], $operator->getValue());
     }
 
-    public function testOperatorCloningWithNewMethods(): void
+    public function test_operator_cloning_with_new_methods(): void
     {
         // Test cloning increment with max
         $operator1 = Operator::increment(5, 10);
@@ -621,7 +608,7 @@ public function testOperatorCloningWithNewMethods(): void
         $this->assertEquals('ham', $removeOp2->getValue());
     }
 
-    public function testSerializationWithNewOperators(): void
+    public function test_serialization_with_new_operators(): void
     {
         // Test serialization of increment with max
         $operator = Operator::increment(5, 100);
@@ -629,9 +616,9 @@ public function testSerializationWithNewOperators(): void
 
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_INCREMENT,
+            'method' => OperatorType::Increment->value,
             'attribute' => 'score',
-            'values' => [5, 100]
+            'values' => [5, 100],
         ];
         $this->assertEquals($expected, $array);
 
@@ -641,9 +628,9 @@ public function testSerializationWithNewOperators(): void
 
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_ARRAY_REMOVE,
+            'method' => OperatorType::ArrayRemove->value,
             'attribute' => 'blacklist',
-            'values' => ['unwanted']
+            'values' => ['unwanted'],
         ];
         $this->assertEquals($expected, $array);
 
@@ -654,7 +641,7 @@ public function testSerializationWithNewOperators(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testMixedOperatorTypes(): void
+    public function test_mixed_operator_types(): void
     {
         // Test that all new operator types can coexist
         $data = [
@@ -678,26 +665,26 @@ public function testMixedOperatorTypes(): void
         $this->assertCount(12, $operators);
 
         // Verify each operator type
-        $this->assertEquals(Operator::TYPE_ARRAY_APPEND, $operators['arrayAppend']->getMethod());
-        $this->assertEquals(Operator::TYPE_INCREMENT, $operators['incrementWithMax']->getMethod());
+        $this->assertEquals(OperatorType::ArrayAppend, $operators['arrayAppend']->getMethod());
+        $this->assertEquals(OperatorType::Increment, $operators['incrementWithMax']->getMethod());
         $this->assertEquals([1, 10], $operators['incrementWithMax']->getValues());
-        $this->assertEquals(Operator::TYPE_DECREMENT, $operators['decrementWithMin']->getMethod());
+        $this->assertEquals(OperatorType::Decrement, $operators['decrementWithMin']->getMethod());
         $this->assertEquals([2, 0], $operators['decrementWithMin']->getValues());
-        $this->assertEquals(Operator::TYPE_MULTIPLY, $operators['multiply']->getMethod());
+        $this->assertEquals(OperatorType::Multiply, $operators['multiply']->getMethod());
         $this->assertEquals([3, 100], $operators['multiply']->getValues());
-        $this->assertEquals(Operator::TYPE_DIVIDE, $operators['divide']->getMethod());
+        $this->assertEquals(OperatorType::Divide, $operators['divide']->getMethod());
         $this->assertEquals([2, 1], $operators['divide']->getValues());
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operators['concat']->getMethod());
-        $this->assertEquals(Operator::TYPE_STRING_REPLACE, $operators['replace']->getMethod());
-        $this->assertEquals(Operator::TYPE_TOGGLE, $operators['toggle']->getMethod());
-        $this->assertEquals(Operator::TYPE_DATE_SET_NOW, $operators['dateSetNow']->getMethod());
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operators['concat']->getMethod());
-        $this->assertEquals(Operator::TYPE_MODULO, $operators['modulo']->getMethod());
-        $this->assertEquals(Operator::TYPE_POWER, $operators['power']->getMethod());
-        $this->assertEquals(Operator::TYPE_ARRAY_REMOVE, $operators['remove']->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operators['concat']->getMethod());
+        $this->assertEquals(OperatorType::StringReplace, $operators['replace']->getMethod());
+        $this->assertEquals(OperatorType::Toggle, $operators['toggle']->getMethod());
+        $this->assertEquals(OperatorType::DateSetNow, $operators['dateSetNow']->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operators['concat']->getMethod());
+        $this->assertEquals(OperatorType::Modulo, $operators['modulo']->getMethod());
+        $this->assertEquals(OperatorType::Power, $operators['power']->getMethod());
+        $this->assertEquals(OperatorType::ArrayRemove, $operators['remove']->getMethod());
     }
 
-    public function testTypeValidationWithNewMethods(): void
+    public function test_type_validation_with_new_methods(): void
     {
         // All new array methods should be detected as array operations
         $this->assertTrue(Operator::arrayAppend([])->isArrayOperation());
@@ -728,7 +715,6 @@ public function testTypeValidationWithNewMethods(): void
         $this->assertFalse(Operator::toggle()->isNumericOperation());
         $this->assertFalse(Operator::toggle()->isArrayOperation());
 
-
         // Test date operations
         $this->assertTrue(Operator::dateSetNow()->isDateOperation());
         $this->assertFalse(Operator::dateSetNow()->isNumericOperation());
@@ -736,33 +722,33 @@ public function testTypeValidationWithNewMethods(): void
 
     // New comprehensive tests for all operators
 
-    public function testStringOperators(): void
+    public function test_string_operators(): void
     {
         // Test concat operator
         $operator = Operator::stringConcat(' - Updated');
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operator->getMethod());
         $this->assertEquals([' - Updated'], $operator->getValues());
         $this->assertEquals(' - Updated', $operator->getValue());
         $this->assertEquals('', $operator->getAttribute());
 
         // Test concat with different values
         $operator = Operator::stringConcat('prefix-');
-        $this->assertEquals(Operator::TYPE_STRING_CONCAT, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringConcat, $operator->getMethod());
         $this->assertEquals(['prefix-'], $operator->getValues());
         $this->assertEquals('prefix-', $operator->getValue());
 
         // Test replace operator
         $operator = Operator::stringReplace('old', 'new');
-        $this->assertEquals(Operator::TYPE_STRING_REPLACE, $operator->getMethod());
+        $this->assertEquals(OperatorType::StringReplace, $operator->getMethod());
         $this->assertEquals(['old', 'new'], $operator->getValues());
         $this->assertEquals('old', $operator->getValue());
     }
 
-    public function testMathOperators(): void
+    public function test_math_operators(): void
     {
         // Test multiply operator
         $operator = Operator::multiply(2.5, 100);
-        $this->assertEquals(Operator::TYPE_MULTIPLY, $operator->getMethod());
+        $this->assertEquals(OperatorType::Multiply, $operator->getMethod());
         $this->assertEquals([2.5, 100], $operator->getValues());
         $this->assertEquals(2.5, $operator->getValue());
 
@@ -772,7 +758,7 @@ public function testMathOperators(): void
 
         // Test divide operator
         $operator = Operator::divide(2, 1);
-        $this->assertEquals(Operator::TYPE_DIVIDE, $operator->getMethod());
+        $this->assertEquals(OperatorType::Divide, $operator->getMethod());
         $this->assertEquals([2, 1], $operator->getValues());
         $this->assertEquals(2, $operator->getValue());
 
@@ -782,13 +768,13 @@ public function testMathOperators(): void
 
         // Test modulo operator
         $operator = Operator::modulo(3);
-        $this->assertEquals(Operator::TYPE_MODULO, $operator->getMethod());
+        $this->assertEquals(OperatorType::Modulo, $operator->getMethod());
         $this->assertEquals([3], $operator->getValues());
         $this->assertEquals(3, $operator->getValue());
 
         // Test power operator
         $operator = Operator::power(2, 1000);
-        $this->assertEquals(Operator::TYPE_POWER, $operator->getMethod());
+        $this->assertEquals(OperatorType::Power, $operator->getMethod());
         $this->assertEquals([2, 1000], $operator->getValues());
         $this->assertEquals(2, $operator->getValue());
 
@@ -797,57 +783,55 @@ public function testMathOperators(): void
         $this->assertEquals([3], $operator->getValues());
     }
 
-    public function testDivideByZero(): void
+    public function test_divide_by_zero(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Division by zero is not allowed');
         Operator::divide(0);
     }
 
-    public function testModuloByZero(): void
+    public function test_modulo_by_zero(): void
     {
         $this->expectException(OperatorException::class);
         $this->expectExceptionMessage('Modulo by zero is not allowed');
         Operator::modulo(0);
     }
 
-    public function testBooleanOperator(): void
+    public function test_boolean_operator(): void
     {
         $operator = Operator::toggle();
-        $this->assertEquals(Operator::TYPE_TOGGLE, $operator->getMethod());
+        $this->assertEquals(OperatorType::Toggle, $operator->getMethod());
         $this->assertEquals([], $operator->getValues());
         $this->assertNull($operator->getValue());
     }
 
-
-    public function testUtilityOperators(): void
+    public function test_utility_operators(): void
     {
         // Test dateSetNow
         $operator = Operator::dateSetNow();
-        $this->assertEquals(Operator::TYPE_DATE_SET_NOW, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateSetNow, $operator->getMethod());
         $this->assertEquals([], $operator->getValues());
         $this->assertNull($operator->getValue());
     }
 
-
-    public function testNewOperatorParsing(): void
+    public function test_new_operator_parsing(): void
     {
         // Test parsing all new operators
         $operators = [
-            ['method' => Operator::TYPE_STRING_CONCAT, 'attribute' => 'title', 'values' => [' - Updated']],
-            ['method' => Operator::TYPE_STRING_CONCAT, 'attribute' => 'subtitle', 'values' => [' - Updated']],
-            ['method' => Operator::TYPE_STRING_REPLACE, 'attribute' => 'content', 'values' => ['old', 'new']],
-            ['method' => Operator::TYPE_MULTIPLY, 'attribute' => 'score', 'values' => [2, 100]],
-            ['method' => Operator::TYPE_DIVIDE, 'attribute' => 'rating', 'values' => [2, 1]],
-            ['method' => Operator::TYPE_MODULO, 'attribute' => 'remainder', 'values' => [3]],
-            ['method' => Operator::TYPE_POWER, 'attribute' => 'exponential', 'values' => [2, 1000]],
-            ['method' => Operator::TYPE_TOGGLE, 'attribute' => 'active', 'values' => []],
-            ['method' => Operator::TYPE_DATE_SET_NOW, 'attribute' => 'updated', 'values' => []],
+            ['method' => OperatorType::StringConcat->value, 'attribute' => 'title', 'values' => [' - Updated']],
+            ['method' => OperatorType::StringConcat->value, 'attribute' => 'subtitle', 'values' => [' - Updated']],
+            ['method' => OperatorType::StringReplace->value, 'attribute' => 'content', 'values' => ['old', 'new']],
+            ['method' => OperatorType::Multiply->value, 'attribute' => 'score', 'values' => [2, 100]],
+            ['method' => OperatorType::Divide->value, 'attribute' => 'rating', 'values' => [2, 1]],
+            ['method' => OperatorType::Modulo->value, 'attribute' => 'remainder', 'values' => [3]],
+            ['method' => OperatorType::Power->value, 'attribute' => 'exponential', 'values' => [2, 1000]],
+            ['method' => OperatorType::Toggle->value, 'attribute' => 'active', 'values' => []],
+            ['method' => OperatorType::DateSetNow->value, 'attribute' => 'updated', 'values' => []],
         ];
 
         foreach ($operators as $operatorData) {
             $operator = Operator::parseOperator($operatorData);
-            $this->assertEquals($operatorData['method'], $operator->getMethod());
+            $this->assertEquals($operatorData['method'], $operator->getMethod()->value);
             $this->assertEquals($operatorData['attribute'], $operator->getAttribute());
             $this->assertEquals($operatorData['values'], $operator->getValues());
 
@@ -860,7 +844,7 @@ public function testNewOperatorParsing(): void
         }
     }
 
-    public function testOperatorCloning(): void
+    public function test_operator_cloning(): void
     {
         // Test cloning all new operator types
         $operators = [
@@ -888,7 +872,7 @@ public function testOperatorCloning(): void
 
     // Test edge cases and error conditions
 
-    public function testOperatorEdgeCases(): void
+    public function test_operator_edge_cases(): void
     {
         // Test multiply with zero
         $operator = Operator::multiply(0);
@@ -915,11 +899,11 @@ public function testOperatorEdgeCases(): void
         $this->assertEquals(0, $operator->getValue());
     }
 
-    public function testPowerOperatorWithMax(): void
+    public function test_power_operator_with_max(): void
     {
         // Test power with max limit
         $operator = Operator::power(2, 1000);
-        $this->assertEquals(Operator::TYPE_POWER, $operator->getMethod());
+        $this->assertEquals(OperatorType::Power, $operator->getMethod());
         $this->assertEquals([2, 1000], $operator->getValues());
 
         // Test power without max
@@ -927,7 +911,7 @@ public function testPowerOperatorWithMax(): void
         $this->assertEquals([3], $operator->getValues());
     }
 
-    public function testOperatorTypeValidation(): void
+    public function test_operator_type_validation(): void
     {
         // Test that operators have proper type checking methods
         $numericOp = Operator::power(2);
@@ -943,11 +927,11 @@ public function testOperatorTypeValidation(): void
     }
 
     // Tests for arrayUnique() method
-    public function testArrayUnique(): void
+    public function test_array_unique(): void
     {
         // Test basic creation
         $operator = Operator::arrayUnique();
-        $this->assertEquals(Operator::TYPE_ARRAY_UNIQUE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayUnique, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([], $operator->getValues());
         $this->assertNull($operator->getValue());
@@ -960,7 +944,7 @@ public function testArrayUnique(): void
         $this->assertFalse($operator->isDateOperation());
     }
 
-    public function testArrayUniqueSerialization(): void
+    public function test_array_unique_serialization(): void
     {
         $operator = Operator::arrayUnique();
         $operator->setAttribute('tags');
@@ -968,9 +952,9 @@ public function testArrayUniqueSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_ARRAY_UNIQUE,
+            'method' => OperatorType::ArrayUnique->value,
             'attribute' => 'tags',
-            'values' => []
+            'values' => [],
         ];
         $this->assertEquals($expected, $array);
 
@@ -981,17 +965,17 @@ public function testArrayUniqueSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testArrayUniqueParsing(): void
+    public function test_array_unique_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_ARRAY_UNIQUE,
+            'method' => OperatorType::ArrayUnique->value,
             'attribute' => 'items',
-            'values' => []
+            'values' => [],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_ARRAY_UNIQUE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayUnique, $operator->getMethod());
         $this->assertEquals('items', $operator->getAttribute());
         $this->assertEquals([], $operator->getValues());
 
@@ -999,12 +983,12 @@ public function testArrayUniqueParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_ARRAY_UNIQUE, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayUnique, $operator->getMethod());
         $this->assertEquals('items', $operator->getAttribute());
         $this->assertEquals([], $operator->getValues());
     }
 
-    public function testArrayUniqueCloning(): void
+    public function test_array_unique_cloning(): void
     {
         $operator1 = Operator::arrayUnique();
         $operator1->setAttribute('original');
@@ -1021,11 +1005,11 @@ public function testArrayUniqueCloning(): void
     }
 
     // Tests for arrayIntersect() method
-    public function testArrayIntersect(): void
+    public function test_array_intersect(): void
     {
         // Test basic creation
         $operator = Operator::arrayIntersect(['a', 'b', 'c']);
-        $this->assertEquals(Operator::TYPE_ARRAY_INTERSECT, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayIntersect, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['a', 'b', 'c'], $operator->getValues());
         $this->assertEquals('a', $operator->getValue());
@@ -1038,7 +1022,7 @@ public function testArrayIntersect(): void
         $this->assertFalse($operator->isDateOperation());
     }
 
-    public function testArrayIntersectEdgeCases(): void
+    public function test_array_intersect_edge_cases(): void
     {
         // Test with empty array
         $operator = Operator::arrayIntersect([]);
@@ -1060,7 +1044,7 @@ public function testArrayIntersectEdgeCases(): void
         $this->assertEquals([['nested'], ['array']], $operator->getValues());
     }
 
-    public function testArrayIntersectSerialization(): void
+    public function test_array_intersect_serialization(): void
     {
         $operator = Operator::arrayIntersect(['x', 'y', 'z']);
         $operator->setAttribute('common');
@@ -1068,9 +1052,9 @@ public function testArrayIntersectSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_ARRAY_INTERSECT,
+            'method' => OperatorType::ArrayIntersect->value,
             'attribute' => 'common',
-            'values' => ['x', 'y', 'z']
+            'values' => ['x', 'y', 'z'],
         ];
         $this->assertEquals($expected, $array);
 
@@ -1081,17 +1065,17 @@ public function testArrayIntersectSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testArrayIntersectParsing(): void
+    public function test_array_intersect_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_ARRAY_INTERSECT,
+            'method' => OperatorType::ArrayIntersect->value,
             'attribute' => 'allowed',
-            'values' => ['admin', 'user']
+            'values' => ['admin', 'user'],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_ARRAY_INTERSECT, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayIntersect, $operator->getMethod());
         $this->assertEquals('allowed', $operator->getAttribute());
         $this->assertEquals(['admin', 'user'], $operator->getValues());
 
@@ -1099,17 +1083,17 @@ public function testArrayIntersectParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_ARRAY_INTERSECT, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayIntersect, $operator->getMethod());
         $this->assertEquals('allowed', $operator->getAttribute());
         $this->assertEquals(['admin', 'user'], $operator->getValues());
     }
 
     // Tests for arrayDiff() method
-    public function testArrayDiff(): void
+    public function test_array_diff(): void
     {
         // Test basic creation
         $operator = Operator::arrayDiff(['remove', 'these']);
-        $this->assertEquals(Operator::TYPE_ARRAY_DIFF, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayDiff, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['remove', 'these'], $operator->getValues());
         $this->assertEquals('remove', $operator->getValue());
@@ -1122,7 +1106,7 @@ public function testArrayDiff(): void
         $this->assertFalse($operator->isDateOperation());
     }
 
-    public function testArrayDiffEdgeCases(): void
+    public function test_array_diff_edge_cases(): void
     {
         // Test with empty array
         $operator = Operator::arrayDiff([]);
@@ -1143,7 +1127,7 @@ public function testArrayDiffEdgeCases(): void
         $this->assertEquals([false, 0, ''], $operator->getValues());
     }
 
-    public function testArrayDiffSerialization(): void
+    public function test_array_diff_serialization(): void
     {
         $operator = Operator::arrayDiff(['spam', 'unwanted']);
         $operator->setAttribute('blocklist');
@@ -1151,9 +1135,9 @@ public function testArrayDiffSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_ARRAY_DIFF,
+            'method' => OperatorType::ArrayDiff->value,
             'attribute' => 'blocklist',
-            'values' => ['spam', 'unwanted']
+            'values' => ['spam', 'unwanted'],
         ];
         $this->assertEquals($expected, $array);
 
@@ -1164,17 +1148,17 @@ public function testArrayDiffSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testArrayDiffParsing(): void
+    public function test_array_diff_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_ARRAY_DIFF,
+            'method' => OperatorType::ArrayDiff->value,
             'attribute' => 'exclude',
-            'values' => ['bad', 'invalid']
+            'values' => ['bad', 'invalid'],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_ARRAY_DIFF, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayDiff, $operator->getMethod());
         $this->assertEquals('exclude', $operator->getAttribute());
         $this->assertEquals(['bad', 'invalid'], $operator->getValues());
 
@@ -1182,17 +1166,17 @@ public function testArrayDiffParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_ARRAY_DIFF, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayDiff, $operator->getMethod());
         $this->assertEquals('exclude', $operator->getAttribute());
         $this->assertEquals(['bad', 'invalid'], $operator->getValues());
     }
 
     // Tests for arrayFilter() method
-    public function testArrayFilter(): void
+    public function test_array_filter(): void
     {
         // Test basic creation with equals condition
         $operator = Operator::arrayFilter('equals', 'active');
-        $this->assertEquals(Operator::TYPE_ARRAY_FILTER, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayFilter, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals(['equals', 'active'], $operator->getValues());
         $this->assertEquals('equals', $operator->getValue());
@@ -1205,7 +1189,7 @@ public function testArrayFilter(): void
         $this->assertFalse($operator->isDateOperation());
     }
 
-    public function testArrayFilterConditions(): void
+    public function test_array_filter_conditions(): void
     {
         // Test different filter conditions
         $operator = Operator::arrayFilter('notEquals', 'inactive');
@@ -1229,7 +1213,7 @@ public function testArrayFilterConditions(): void
         $this->assertEquals(['null', null], $operator->getValues());
     }
 
-    public function testArrayFilterEdgeCases(): void
+    public function test_array_filter_edge_cases(): void
     {
         // Test with boolean value
         $operator = Operator::arrayFilter('equals', true);
@@ -1248,7 +1232,7 @@ public function testArrayFilterEdgeCases(): void
         $this->assertEquals(['equals', ['nested', 'array']], $operator->getValues());
     }
 
-    public function testArrayFilterSerialization(): void
+    public function test_array_filter_serialization(): void
     {
         $operator = Operator::arrayFilter('greaterThan', 100);
         $operator->setAttribute('scores');
@@ -1256,9 +1240,9 @@ public function testArrayFilterSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_ARRAY_FILTER,
+            'method' => OperatorType::ArrayFilter->value,
             'attribute' => 'scores',
-            'values' => ['greaterThan', 100]
+            'values' => ['greaterThan', 100],
         ];
         $this->assertEquals($expected, $array);
 
@@ -1269,17 +1253,17 @@ public function testArrayFilterSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testArrayFilterParsing(): void
+    public function test_array_filter_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_ARRAY_FILTER,
+            'method' => OperatorType::ArrayFilter->value,
             'attribute' => 'ratings',
-            'values' => ['lessThan', 3]
+            'values' => ['lessThan', 3],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_ARRAY_FILTER, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayFilter, $operator->getMethod());
         $this->assertEquals('ratings', $operator->getAttribute());
         $this->assertEquals(['lessThan', 3], $operator->getValues());
 
@@ -1287,17 +1271,17 @@ public function testArrayFilterParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_ARRAY_FILTER, $operator->getMethod());
+        $this->assertEquals(OperatorType::ArrayFilter, $operator->getMethod());
         $this->assertEquals('ratings', $operator->getAttribute());
         $this->assertEquals(['lessThan', 3], $operator->getValues());
     }
 
     // Tests for dateAddDays() method
-    public function testDateAddDays(): void
+    public function test_date_add_days(): void
     {
         // Test basic creation
         $operator = Operator::dateAddDays(7);
-        $this->assertEquals(Operator::TYPE_DATE_ADD_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateAddDays, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([7], $operator->getValues());
         $this->assertEquals(7, $operator->getValue());
@@ -1310,7 +1294,7 @@ public function testDateAddDays(): void
         $this->assertFalse($operator->isBooleanOperation());
     }
 
-    public function testDateAddDaysEdgeCases(): void
+    public function test_date_add_days_edge_cases(): void
     {
         // Test with zero days
         $operator = Operator::dateAddDays(0);
@@ -1333,7 +1317,7 @@ public function testDateAddDaysEdgeCases(): void
         $this->assertEquals(-1000, $operator->getValue());
     }
 
-    public function testDateAddDaysSerialization(): void
+    public function test_date_add_days_serialization(): void
     {
         $operator = Operator::dateAddDays(30);
         $operator->setAttribute('expiresAt');
@@ -1341,9 +1325,9 @@ public function testDateAddDaysSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_DATE_ADD_DAYS,
+            'method' => OperatorType::DateAddDays->value,
             'attribute' => 'expiresAt',
-            'values' => [30]
+            'values' => [30],
         ];
         $this->assertEquals($expected, $array);
 
@@ -1354,17 +1338,17 @@ public function testDateAddDaysSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testDateAddDaysParsing(): void
+    public function test_date_add_days_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_DATE_ADD_DAYS,
+            'method' => OperatorType::DateAddDays->value,
             'attribute' => 'scheduledFor',
-            'values' => [14]
+            'values' => [14],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_DATE_ADD_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateAddDays, $operator->getMethod());
         $this->assertEquals('scheduledFor', $operator->getAttribute());
         $this->assertEquals([14], $operator->getValues());
 
@@ -1372,12 +1356,12 @@ public function testDateAddDaysParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_DATE_ADD_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateAddDays, $operator->getMethod());
         $this->assertEquals('scheduledFor', $operator->getAttribute());
         $this->assertEquals([14], $operator->getValues());
     }
 
-    public function testDateAddDaysCloning(): void
+    public function test_date_add_days_cloning(): void
     {
         $operator1 = Operator::dateAddDays(10);
         $operator1->setAttribute('date1');
@@ -1394,11 +1378,11 @@ public function testDateAddDaysCloning(): void
     }
 
     // Tests for dateSubDays() method
-    public function testDateSubDays(): void
+    public function test_date_sub_days(): void
     {
         // Test basic creation
         $operator = Operator::dateSubDays(3);
-        $this->assertEquals(Operator::TYPE_DATE_SUB_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateSubDays, $operator->getMethod());
         $this->assertEquals('', $operator->getAttribute());
         $this->assertEquals([3], $operator->getValues());
         $this->assertEquals(3, $operator->getValue());
@@ -1411,7 +1395,7 @@ public function testDateSubDays(): void
         $this->assertFalse($operator->isBooleanOperation());
     }
 
-    public function testDateSubDaysEdgeCases(): void
+    public function test_date_sub_days_edge_cases(): void
     {
         // Test with zero days
         $operator = Operator::dateSubDays(0);
@@ -1434,7 +1418,7 @@ public function testDateSubDaysEdgeCases(): void
         $this->assertEquals(10000, $operator->getValue());
     }
 
-    public function testDateSubDaysSerialization(): void
+    public function test_date_sub_days_serialization(): void
     {
         $operator = Operator::dateSubDays(7);
         $operator->setAttribute('reminderDate');
@@ -1442,9 +1426,9 @@ public function testDateSubDaysSerialization(): void
         // Test toArray
         $array = $operator->toArray();
         $expected = [
-            'method' => Operator::TYPE_DATE_SUB_DAYS,
+            'method' => OperatorType::DateSubDays->value,
             'attribute' => 'reminderDate',
-            'values' => [7]
+            'values' => [7],
         ];
         $this->assertEquals($expected, $array);
 
@@ -1455,17 +1439,17 @@ public function testDateSubDaysSerialization(): void
         $this->assertEquals($expected, $decoded);
     }
 
-    public function testDateSubDaysParsing(): void
+    public function test_date_sub_days_parsing(): void
     {
         // Test parseOperator from array
         $array = [
-            'method' => Operator::TYPE_DATE_SUB_DAYS,
+            'method' => OperatorType::DateSubDays->value,
             'attribute' => 'dueDate',
-            'values' => [5]
+            'values' => [5],
         ];
 
         $operator = Operator::parseOperator($array);
-        $this->assertEquals(Operator::TYPE_DATE_SUB_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateSubDays, $operator->getMethod());
         $this->assertEquals('dueDate', $operator->getAttribute());
         $this->assertEquals([5], $operator->getValues());
 
@@ -1473,12 +1457,12 @@ public function testDateSubDaysParsing(): void
         $json = json_encode($array);
         $this->assertIsString($json);
         $operator = Operator::parse($json);
-        $this->assertEquals(Operator::TYPE_DATE_SUB_DAYS, $operator->getMethod());
+        $this->assertEquals(OperatorType::DateSubDays, $operator->getMethod());
         $this->assertEquals('dueDate', $operator->getAttribute());
         $this->assertEquals([5], $operator->getValues());
     }
 
-    public function testDateSubDaysCloning(): void
+    public function test_date_sub_days_cloning(): void
     {
         $operator1 = Operator::dateSubDays(15);
         $operator1->setAttribute('date1');
@@ -1495,18 +1479,18 @@ public function testDateSubDaysCloning(): void
     }
 
     // Integration tests for all six new operators
-    public function testIsMethodForNewOperators(): void
+    public function test_is_method_for_new_operators(): void
     {
         // Test that all new operators are valid methods
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_UNIQUE));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_INTERSECT));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_DIFF));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_ARRAY_FILTER));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_DATE_ADD_DAYS));
-        $this->assertTrue(Operator::isMethod(Operator::TYPE_DATE_SUB_DAYS));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayUnique->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayIntersect->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayDiff->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayFilter->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::DateAddDays->value));
+        $this->assertTrue(Operator::isMethod(OperatorType::DateSubDays->value));
     }
 
-    public function testExtractOperatorsWithNewOperators(): void
+    public function test_extract_operators_with_new_operators(): void
     {
         $data = [
             'uniqueTags' => Operator::arrayUnique(),
@@ -1527,25 +1511,43 @@ public function testExtractOperatorsWithNewOperators(): void
         $this->assertCount(6, $operators);
 
         // Check each operator type
-        $this->assertInstanceOf(Operator::class, $operators['uniqueTags']);
-        $this->assertEquals(Operator::TYPE_ARRAY_UNIQUE, $operators['uniqueTags']->getMethod());
+        $this->assertEquals(OperatorType::ArrayUnique, $operators['uniqueTags']->getMethod());
+        $this->assertEquals(OperatorType::ArrayIntersect, $operators['commonItems']->getMethod());
+        $this->assertEquals(OperatorType::ArrayDiff, $operators['filteredList']->getMethod());
+        $this->assertEquals(OperatorType::ArrayFilter, $operators['activeUsers']->getMethod());
+        $this->assertEquals(OperatorType::DateAddDays, $operators['expiry']->getMethod());
+        $this->assertEquals(OperatorType::DateSubDays, $operators['reminder']->getMethod());
 
-        $this->assertInstanceOf(Operator::class, $operators['commonItems']);
-        $this->assertEquals(Operator::TYPE_ARRAY_INTERSECT, $operators['commonItems']->getMethod());
+        // Check updates
+        $this->assertEquals(['name' => 'Regular value'], $updates);
+    }
 
-        $this->assertInstanceOf(Operator::class, $operators['filteredList']);
-        $this->assertEquals(Operator::TYPE_ARRAY_DIFF, $operators['filteredList']->getMethod());
+    public function test_clone_deep_copies_nested_operator_values(): void
+    {
+        $nested = Operator::increment(1);
+        $parent = new Operator(OperatorType::ArrayAppend, 'items', [$nested, 'plain']);
 
-        $this->assertInstanceOf(Operator::class, $operators['activeUsers']);
-        $this->assertEquals(Operator::TYPE_ARRAY_FILTER, $operators['activeUsers']->getMethod());
+        $cloned = clone $parent;
 
-        $this->assertInstanceOf(Operator::class, $operators['expiry']);
-        $this->assertEquals(Operator::TYPE_DATE_ADD_DAYS, $operators['expiry']->getMethod());
+        $parentValues = $parent->getValues();
+        $clonedValues = $cloned->getValues();
 
-        $this->assertInstanceOf(Operator::class, $operators['reminder']);
-        $this->assertEquals(Operator::TYPE_DATE_SUB_DAYS, $operators['reminder']->getMethod());
+        $this->assertNotSame($parentValues[0], $clonedValues[0]);
+        $this->assertInstanceOf(Operator::class, $clonedValues[0]);
+        $this->assertInstanceOf(Operator::class, $parentValues[0]);
+        $this->assertEquals($nested->getMethod(), $clonedValues[0]->getMethod());
+        $this->assertEquals($nested->getValues(), $clonedValues[0]->getValues());
 
-        // Check updates
-        $this->assertEquals(['name' => 'Regular value'], $updates);
+        $clonedValues[0]->setMethod(OperatorType::Decrement);
+        $this->assertEquals(OperatorType::Increment, $parentValues[0]->getMethod());
+    }
+
+    public function test_is_method_with_operator_type_enum(): void
+    {
+        $this->assertTrue(Operator::isMethod(OperatorType::Increment));
+        $this->assertTrue(Operator::isMethod(OperatorType::Decrement));
+        $this->assertTrue(Operator::isMethod(OperatorType::ArrayAppend));
+        $this->assertTrue(Operator::isMethod(OperatorType::Toggle));
+        $this->assertTrue(Operator::isMethod(OperatorType::DateSetNow));
     }
 }
diff --git a/tests/unit/PDOStatementTest.php b/tests/unit/PDOStatementTest.php
index 8bd8f280b7..7ff6558394 100644
--- a/tests/unit/PDOStatementTest.php
+++ b/tests/unit/PDOStatementTest.php
@@ -7,7 +7,7 @@
 use Utopia\Database\PDO;
 use Utopia\Database\PDOStatement;
 
-class PDOStatementTest extends TestCase
+final class PDOStatementTest extends TestCase
 {
     /**
      * @return PDO&\PHPUnit\Framework\MockObject\MockObject
@@ -16,8 +16,7 @@ private function pdoMock(bool $inTransaction): PDO
     {
         $pdo = $this->getMockBuilder(PDO::class)
             ->disableOriginalConstructor()
-            ->onlyMethods(['reconnect', 'prepareNative'])
-            ->addMethods(['inTransaction'])
+            ->onlyMethods(['inTransaction', 'prepareNative', 'reconnect'])
             ->getMock();
 
         $pdo->method('inTransaction')->willReturn($inTransaction);
@@ -129,7 +128,6 @@ public function testIsIterableAndDelegatesIterationToTheStatement(): void
 
         $wrapper = new PDOStatement($pdo, $statement, 'SELECT 1');
 
-        $this->assertInstanceOf(\IteratorAggregate::class, $wrapper);
         $this->assertSame($statement, $wrapper->getIterator());
     }
 
@@ -199,11 +197,11 @@ public function testReplaysMixedBindingsInOriginalCallOrder(): void
         $replay = [];
         $second = $this->statementMock();
         $second->method('bindValue')->willReturnCallback(function (int|string $p, mixed $v) use (&$replay): bool {
-            $replay[] = "value:{$v}";
+            $replay[] = ['value', $v];
             return true;
         });
         $second->method('bindParam')->willReturnCallback(function (int|string $p, mixed &$v) use (&$replay): bool {
-            $replay[] = "param:{$v}";
+            $replay[] = ['param', $v];
             return true;
         });
         $second->expects($this->once())->method('execute')->willReturn(true);
@@ -219,6 +217,6 @@ public function testReplaysMixedBindingsInOriginalCallOrder(): void
         $wrapper->bindParam(':id', $current);
 
         $this->assertTrue($wrapper->execute());
-        $this->assertSame(['value:old', 'param:new'], $replay, 'replay must preserve original bind order so the last binding wins');
+        $this->assertSame([['value', 'old'], ['param', 'new']], $replay, 'replay must preserve original bind order so the last binding wins');
     }
 }
diff --git a/tests/unit/PDOTest.php b/tests/unit/PDOTest.php
index 09e4ac122d..c516423681 100644
--- a/tests/unit/PDOTest.php
+++ b/tests/unit/PDOTest.php
@@ -9,7 +9,7 @@
 
 class PDOTest extends TestCase
 {
-    public function testMethodCallIsForwardedToPDO(): void
+    public function test_method_call_is_forwarded_to_pdo(): void
     {
         $dsn = 'sqlite::memory:';
         $pdoWrapper = new PDO($dsn, null, null);
@@ -17,32 +17,28 @@ public function testMethodCallIsForwardedToPDO(): void
         // Use Reflection to replace the internal PDO instance with a mock
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
 
         // Create a mock for the internal \PDO object.
         $pdoMock = $this->getMockBuilder(\PDO::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        // Create a PDOStatement mock since query returns a PDOStatement
-        $pdoStatementMock = $this->getMockBuilder(\PDOStatement::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $pdoStatementStub = self::createStub(\PDOStatement::class);
 
-        // Expect that when we call 'query', the mock returns our PDOStatement mock.
+        // Expect that when we call 'query', the mock returns our PDOStatement stub.
         $pdoMock->expects($this->once())
             ->method('query')
             ->with('SELECT 1')
-            ->willReturn($pdoStatementMock);
+            ->willReturn($pdoStatementStub);
 
         $pdoProperty->setValue($pdoWrapper, $pdoMock);
 
         $result = $pdoWrapper->query('SELECT 1');
 
-        $this->assertSame($pdoStatementMock, $result);
+        $this->assertSame($pdoStatementStub, $result);
     }
 
-    public function testLostConnectionRetriesCall(): void
+    public function test_lost_connection_retries_call(): void
     {
         $dsn = 'sqlite::memory:';
         $pdoWrapper = $this->getMockBuilder(PDO::class)
@@ -53,21 +49,22 @@ public function testLostConnectionRetriesCall(): void
         $pdoMock = $this->getMockBuilder(\PDO::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $pdoStatementMock = $this->getMockBuilder(\PDOStatement::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $pdoStatementStub = self::createStub(\PDOStatement::class);
 
+        $callCount = 0;
         $pdoMock->expects($this->exactly(2))
             ->method('query')
             ->with('SELECT 1')
-            ->will($this->onConsecutiveCalls(
-                $this->throwException(new \Exception("Lost connection")),
-                $pdoStatementMock
-            ));
+            ->willReturnCallback(function () use (&$callCount, $pdoStatementStub) {
+                $callCount++;
+                if ($callCount === 1) {
+                    throw new \Exception('Lost connection');
+                }
+                return $pdoStatementStub;
+            });
 
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
         $pdoProperty->setValue($pdoWrapper, $pdoMock);
 
         $pdoWrapper->expects($this->once())
@@ -78,17 +75,16 @@ public function testLostConnectionRetriesCall(): void
 
         $result = $pdoWrapper->query('SELECT 1');
 
-        $this->assertSame($pdoStatementMock, $result);
+        $this->assertSame($pdoStatementStub, $result);
     }
 
-    public function testNonLostConnectionExceptionIsRethrown(): void
+    public function test_non_lost_connection_exception_is_rethrown(): void
     {
         $dsn = 'sqlite::memory:';
         $pdoWrapper = new PDO($dsn, null, null);
 
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
 
         $pdoMock = $this->getMockBuilder(\PDO::class)
             ->disableOriginalConstructor()
@@ -97,60 +93,55 @@ public function testNonLostConnectionExceptionIsRethrown(): void
         $pdoMock->expects($this->once())
             ->method('query')
             ->with('SELECT 1')
-            ->will($this->throwException(new \Exception("Other error")));
+            ->will($this->throwException(new \Exception('Other error')));
 
         $pdoProperty->setValue($pdoWrapper, $pdoMock);
 
         $this->expectException(\Exception::class);
-        $this->expectExceptionMessage("Other error");
+        $this->expectExceptionMessage('Other error');
 
         $pdoWrapper->query('SELECT 1');
     }
 
-    public function testReconnectCreatesNewPDOInstance(): void
+    public function test_reconnect_creates_new_pdo_instance(): void
     {
         $dsn = 'sqlite::memory:';
         $pdoWrapper = new PDO($dsn, null, null);
 
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
 
         $oldPDO = $pdoProperty->getValue($pdoWrapper);
         $pdoWrapper->reconnect();
         $newPDO = $pdoProperty->getValue($pdoWrapper);
 
-        $this->assertNotSame($oldPDO, $newPDO, "Reconnect should create a new PDO instance");
+        $this->assertNotSame($oldPDO, $newPDO, 'Reconnect should create a new PDO instance');
     }
 
-    public function testMethodCallForPrepare(): void
+    public function test_method_call_for_prepare(): void
     {
         $dsn = 'sqlite::memory:';
         $pdoWrapper = new PDO($dsn, null, null);
 
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
 
         $pdoMock = $this->getMockBuilder(\PDO::class)
             ->disableOriginalConstructor()
             ->getMock();
 
-        $pdoStatementMock = $this->getMockBuilder(\PDOStatement::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $pdoStatementStub = self::createStub(\PDOStatement::class);
 
         $pdoMock->expects($this->once())
             ->method('prepare')
             ->with('SELECT * FROM table', [\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY])
-            ->willReturn($pdoStatementMock);
+            ->willReturn($pdoStatementStub);
 
         $pdoProperty->setValue($pdoWrapper, $pdoMock);
 
         $result = $pdoWrapper->prepare('SELECT * FROM table', [\PDO::ATTR_CURSOR => \PDO::CURSOR_FWDONLY]);
 
-        $this->assertInstanceOf(PDOStatement::class, $result);
-        $this->assertSame($pdoStatementMock, $result->getStatement());
+        $this->assertSame($pdoStatementStub, $result->getStatement());
     }
 
     public function testPrepareNativeReconnectsOutsideTransaction(): void
@@ -163,26 +154,50 @@ public function testPrepareNativeReconnectsOutsideTransaction(): void
         $pdoMock = $this->getMockBuilder(\PDO::class)
             ->disableOriginalConstructor()
             ->getMock();
-        $statementMock = $this->getMockBuilder(\PDOStatement::class)
-            ->disableOriginalConstructor()
-            ->getMock();
+        $statement = self::createStub(\PDOStatement::class);
 
         $pdoMock->method('inTransaction')->willReturn(false);
+        $calls = 0;
         $pdoMock->expects($this->exactly(2))
             ->method('prepare')
-            ->with('SELECT 1')
-            ->willReturnOnConsecutiveCalls(
-                $this->throwException(new \PDOException('server has gone away')),
-                $statementMock
-            );
+            ->with('SELECT 1', [])
+            ->willReturnCallback(function () use (&$calls, $statement): \PDOStatement {
+                $calls++;
+                if ($calls === 1) {
+                    throw new \PDOException('server has gone away');
+                }
+
+                return $statement;
+            });
 
         $reflection = new ReflectionClass($pdoWrapper);
         $pdoProperty = $reflection->getProperty('pdo');
-        $pdoProperty->setAccessible(true);
         $pdoProperty->setValue($pdoWrapper, $pdoMock);
 
         $pdoWrapper->expects($this->once())->method('reconnect');
 
-        $this->assertSame($statementMock, $pdoWrapper->prepareNative('SELECT 1'));
+        $this->assertSame($statement, $pdoWrapper->prepareNative('SELECT 1'));
+    }
+
+    public function testPrepareNativeThrowsWhenNativePrepareReturnsFalse(): void
+    {
+        $pdoWrapper = new PDO('sqlite::memory:', null, null);
+
+        $pdoMock = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdoMock->expects($this->once())
+            ->method('prepare')
+            ->with('INVALID', [])
+            ->willReturn(false);
+
+        $reflection = new ReflectionClass($pdoWrapper);
+        $pdoProperty = $reflection->getProperty('pdo');
+        $pdoProperty->setValue($pdoWrapper, $pdoMock);
+
+        $this->expectException(\PDOException::class);
+        $this->expectExceptionMessage('Failed to prepare statement: INVALID');
+
+        $pdoWrapper->prepareNative('INVALID');
     }
 }
diff --git a/tests/unit/PermissionTest.php b/tests/unit/PermissionTest.php
index 6ca554f378..7c4ce45bab 100644
--- a/tests/unit/PermissionTest.php
+++ b/tests/unit/PermissionTest.php
@@ -3,14 +3,14 @@
 namespace Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\PermissionType;
 
 class PermissionTest extends TestCase
 {
-    public function testOutputFromString(): void
+    public function test_output_from_string(): void
     {
         $permission = Permission::parse('read("any")');
         $this->assertEquals('read', $permission->getPermission());
@@ -141,7 +141,7 @@ public function testOutputFromString(): void
         $this->assertEquals('unverified', $permission->getDimension());
     }
 
-    public function testInputFromParameters(): void
+    public function test_input_from_parameters(): void
     {
         $permission = new Permission('read', 'any');
         $this->assertEquals('read("any")', $permission->toString());
@@ -192,7 +192,7 @@ public function testInputFromParameters(): void
         $this->assertEquals('delete("team:123/admin")', $permission->toString());
     }
 
-    public function testInputFromRoles(): void
+    public function test_input_from_roles(): void
     {
         $permission = Permission::read(Role::any());
         $this->assertEquals('read("any")', $permission);
@@ -258,7 +258,7 @@ public function testInputFromRoles(): void
         $this->assertEquals('write("any")', $permission);
     }
 
-    public function testInvalidFormats(): void
+    public function test_invalid_formats(): void
     {
         try {
             Permission::parse('read');
@@ -292,13 +292,13 @@ public function testInvalidFormats(): void
     /**
      * @throws \Exception
      */
-    public function testAggregation(): void
+    public function test_aggregation(): void
     {
         $permissions = ['write("any")'];
         $parsed = Permission::aggregate($permissions);
         $this->assertEquals(['create("any")', 'update("any")', 'delete("any")'], $parsed);
 
-        $parsed = Permission::aggregate($permissions, [Database::PERMISSION_UPDATE, Database::PERMISSION_DELETE]);
+        $parsed = Permission::aggregate($permissions, [PermissionType::Update, PermissionType::Delete]);
         $this->assertEquals(['update("any")', 'delete("any")'], $parsed);
 
         $permissions = [
@@ -307,10 +307,10 @@ public function testAggregation(): void
             'read("user:123")',
             'write("user:123")',
             'update("user:123")',
-            'delete("user:123")'
+            'delete("user:123")',
         ];
 
-        $parsed = Permission::aggregate($permissions, Database::PERMISSIONS);
+        $parsed = Permission::aggregate($permissions, [PermissionType::Create, PermissionType::Read, PermissionType::Update, PermissionType::Delete]);
         $this->assertEquals([
             'read("any")',
             'read("user:123")',
diff --git a/tests/unit/PoolTimeoutTest.php b/tests/unit/PoolTimeoutTest.php
index 2dcab66d9b..5558534165 100644
--- a/tests/unit/PoolTimeoutTest.php
+++ b/tests/unit/PoolTimeoutTest.php
@@ -3,9 +3,10 @@
 namespace Tests\Unit;
 
 use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\Feature;
 use Utopia\Database\Adapter\Memory;
 use Utopia\Database\Adapter\Pool;
-use Utopia\Database\Database;
+use Utopia\Database\Event;
 use Utopia\Database\Validator\Authorization;
 use Utopia\Pools\Adapter\Stack;
 use Utopia\Pools\Pool as UtopiaPool;
@@ -45,14 +46,14 @@ public function testTimeoutIsAppliedToEveryCheckout(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(300000);
-        $adapter->getSupportForTimeouts();
+        $adapter->getDriver();
 
-        $this->assertSame([Database::EVENT_ALL => 300000], $connection->timeouts);
+        $this->assertSame([Event::All->value => 300000], $connection->timeouts);
 
         $connection->timeouts = [];
-        $adapter->getSupportForTimeouts();
+        $adapter->getDriver();
 
-        $this->assertSame([Database::EVENT_ALL => 300000], $connection->timeouts);
+        $this->assertSame([Event::All->value => 300000], $connection->timeouts);
     }
 
     public function testClearedTimeoutIsClearedOnEveryCheckout(): void
@@ -62,9 +63,9 @@ public function testClearedTimeoutIsClearedOnEveryCheckout(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(300000);
-        $adapter->getSupportForTimeouts();
-        $adapter->clearTimeout(Database::EVENT_ALL);
-        $adapter->getSupportForTimeouts();
+        $adapter->getDriver();
+        $adapter->clearTimeout(Event::All);
+        $adapter->getDriver();
 
         $this->assertSame([], $connection->timeouts);
         $this->assertSame(0, $connection->getTimeout());
@@ -78,12 +79,12 @@ public function testPerEventTimeoutReachesTheConnection(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(300000);
-        $adapter->setTimeout(5000, Database::EVENT_DOCUMENT_READ);
-        $adapter->getSupportForTimeouts();
+        $adapter->setTimeout(5000, Event::DocumentRead);
+        $adapter->getDriver();
 
         $this->assertSame([
-            Database::EVENT_DOCUMENT_READ => 5000,
-            Database::EVENT_ALL => 300000,
+            Event::DocumentRead->value => 5000,
+            Event::All->value => 300000,
         ], $connection->timeouts, 'The global timeout is applied last so the connection ends on the scalar the pool reports');
         $this->assertSame(300000, $connection->getTimeout());
     }
@@ -101,11 +102,11 @@ public function testClearingOneEventLeavesTheGlobalTimeoutInPlace(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(300000);
-        $adapter->setTimeout(5000, Database::EVENT_DOCUMENT_READ);
-        $adapter->clearTimeout(Database::EVENT_DOCUMENT_READ);
-        $adapter->getSupportForTimeouts();
+        $adapter->setTimeout(5000, Event::DocumentRead);
+        $adapter->clearTimeout(Event::DocumentRead);
+        $adapter->getDriver();
 
-        $this->assertSame([Database::EVENT_ALL => 300000], $connection->timeouts);
+        $this->assertSame([Event::All->value => 300000], $connection->timeouts);
         $this->assertSame(300000, $connection->getTimeout(), 'Postgres and Mongo bound every statement by this scalar, so clearing one event must not zero it');
         $this->assertSame(300000, $adapter->getTimeout());
     }
@@ -124,11 +125,11 @@ public function testHandleWithNoTimeoutResetsTheConnectionItIsGiven(): void
         $bounded = new Pool($pool);
         $bounded->setAuthorization(new Authorization());
         $bounded->setTimeout(5000);
-        $bounded->getSupportForTimeouts();
+        $bounded->getDriver();
 
         $unbounded = new Pool($pool);
         $unbounded->setAuthorization(new Authorization());
-        $unbounded->getSupportForTimeouts();
+        $unbounded->getDriver();
 
         $this->assertSame([], $connection->timeouts, 'A handle that asked for no timeout must not run under the last holder\'s');
         $this->assertSame(0, $connection->getTimeout());
@@ -148,9 +149,9 @@ public function testClearingEveryTimeoutDropsPerEventEntriesToo(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(300000);
-        $adapter->setTimeout(5000, Database::EVENT_DOCUMENT_READ);
-        $adapter->clearTimeouts();
-        $adapter->getSupportForTimeouts();
+        $adapter->setTimeout(5000, Event::DocumentRead);
+        $adapter->clearTimeout(Event::All);
+        $adapter->getDriver();
 
         $this->assertSame([], $connection->timeouts, 'A timeout the caller cleared must not come back on the next checkout');
         $this->assertSame(0, $adapter->getTimeout());
@@ -175,13 +176,13 @@ public function testTimeoutChangedInsideATransactionReachesThePinnedConnection()
             $adapter->setTimeout(300000);
             $insideBody['raised'] = $connection->timeouts;
 
-            $adapter->clearTimeout(Database::EVENT_ALL);
+            $adapter->clearTimeout(Event::All);
             $insideBody['cleared'] = $connection->timeouts;
 
             return 'row-written';
         });
 
-        $this->assertSame([Database::EVENT_ALL => 300000], $insideBody['raised'], 'The rest of the body runs on this connection, so the new timeout must reach it before the commit');
+        $this->assertSame([Event::All->value => 300000], $insideBody['raised'], 'The rest of the body runs on this connection, so the new timeout must reach it before the commit');
         $this->assertSame([], $insideBody['cleared']);
     }
 
@@ -197,7 +198,7 @@ public function testZeroIsHeldAsNoTimeout(): void
 
         $adapter->setAuthorization(new Authorization());
         $adapter->setTimeout(0);
-        $adapter->getSupportForTimeouts();
+        $adapter->getDriver();
 
         $this->assertSame([], $connection->timeouts);
         $this->assertSame(0, $adapter->getTimeout());
@@ -208,23 +209,28 @@ public function testZeroIsHeldAsNoTimeout(): void
  * Stands in for a connection: records what the pooled adapter applied to it,
  * the way a concrete adapter records a timeout for the statements it builds.
  */
-class TimeoutRecordingMemory extends Memory
+class TimeoutRecordingMemory extends Memory implements Feature\Timeouts
 {
     /**
      * @var array<string, int>
      */
     public array $timeouts = [];
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
-        $this->timeouts[$event] = $milliseconds;
+        $this->timeouts[$event->value] = $milliseconds;
         $this->timeout = $milliseconds;
     }
 
-    public function clearTimeout(string $event): void
+    public function clearTimeout(Event $event = Event::All): void
     {
-        unset($this->timeouts[$event]);
+        if ($event === Event::All) {
+            $this->timeouts = [];
+            $this->timeout = 0;
 
-        parent::clearTimeout($event);
+            return;
+        }
+
+        unset($this->timeouts[$event->value]);
     }
 }
diff --git a/tests/unit/PostgresIdentifierTest.php b/tests/unit/PostgresIdentifierTest.php
new file mode 100644
index 0000000000..cb85dce53a
--- /dev/null
+++ b/tests/unit/PostgresIdentifierTest.php
@@ -0,0 +1,124 @@
+<?php
+
+namespace Tests\Unit;
+
+use PDO;
+use PDOStatement;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+
+final class PostgresIdentifierTest extends TestCase
+{
+    public function testCreateAndLookupShareHashedNameForMongoShapedCollection(): void
+    {
+        $namespace = '_507f1f77bcf86cd799439011';
+        $collection = 'database_507f1f77bcf86cd799439012_collection_507f1f77bcf86cd799439013';
+        $unhashed = $namespace.'_'.$collection;
+        $this->assertGreaterThan(Postgres::MAX_IDENTIFIER_NAME, \strlen($unhashed));
+
+        $adapter = new Postgres($this->createStub(PDO::class));
+        $adapter->setDatabase('appwrite');
+        $adapter->setNamespace($namespace);
+
+        $physical = $this->invoke($adapter, 'getPhysicalTableName', $collection);
+        $quoted = $this->invoke($adapter, 'getSQLTable', $collection);
+        $raw = $this->invoke($adapter, 'getSQLTableRaw', $collection);
+
+        $this->assertNotSame($unhashed, $physical);
+        $this->assertLessThanOrEqual(Postgres::MAX_IDENTIFIER_NAME, \strlen($physical));
+        $this->assertSame('"appwrite"."'.$physical.'"', $quoted);
+        $this->assertSame('appwrite.'.$physical, $raw);
+    }
+
+    public function testCreateCollectionSqlUsesHashedTableName(): void
+    {
+        $namespace = '_507f1f77bcf86cd799439011';
+        $collection = 'database_507f1f77bcf86cd799439012_collection_507f1f77bcf86cd799439013';
+
+        $statement = $this->getMockBuilder(PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->exactly(2))
+            ->method('execute')
+            ->willReturn(true);
+
+        $queries = [];
+        $pdo = $this->getMockBuilder(PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('prepare')
+            ->willReturnCallback(function (string $sql) use (&$queries, $statement): PDOStatement {
+                $queries[] = $sql;
+
+                return $statement;
+            });
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('appwrite');
+        $adapter->setNamespace($namespace);
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $physical = $this->invoke($adapter, 'getPhysicalTableName', $collection);
+        $permissions = $this->invoke($adapter, 'getPhysicalTableName', Storage::permissionsTable($collection));
+
+        $this->assertTrue($adapter->createCollection($collection));
+        $this->assertNotSame($namespace.'_'.$collection, $physical);
+        $this->assertStringContainsString('"'.$physical.'"', $queries[0]);
+        $this->assertStringNotContainsString($collection, $queries[0]);
+        $this->assertStringContainsString('"'.$permissions.'"', $queries[1]);
+    }
+
+    public function testExistsBindsHashedTableName(): void
+    {
+        $namespace = '_507f1f77bcf86cd799439011';
+        $collection = 'database_507f1f77bcf86cd799439012_collection_507f1f77bcf86cd799439013';
+        $bound = [];
+
+        $statement = $this->getMockBuilder(PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->exactly(2))
+            ->method('bindValue')
+            ->willReturnCallback(function (int $position, mixed $value) use (&$bound): bool {
+                $bound[$position] = $value;
+
+                return true;
+            });
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([['table_name' => 'hashed']]);
+        $statement->expects($this->once())->method('closeCursor')->willReturn(true);
+
+        $pdo = $this->getMockBuilder(PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturn($statement);
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('appwrite');
+        $adapter->setNamespace($namespace);
+
+        $physical = $this->invoke($adapter, 'getPhysicalTableName', $collection);
+
+        $this->assertTrue($adapter->exists('appwrite', $collection));
+        $this->assertSame('appwrite', $bound[1]);
+        $this->assertSame($physical, $bound[2]);
+        $this->assertNotSame($namespace.'_'.$collection, $bound[2]);
+    }
+
+    private function invoke(Postgres $adapter, string $method, string ...$arguments): string
+    {
+        $reflection = new ReflectionMethod($adapter, $method);
+        $result = $reflection->invoke($adapter, ...$arguments);
+        $this->assertIsString($result);
+
+        return $result;
+    }
+}
diff --git a/tests/unit/PostgresQueryBehaviorTest.php b/tests/unit/PostgresQueryBehaviorTest.php
new file mode 100644
index 0000000000..73a2aecfd7
--- /dev/null
+++ b/tests/unit/PostgresQueryBehaviorTest.php
@@ -0,0 +1,274 @@
+<?php
+
+namespace Tests\Unit;
+
+use Exception;
+use PDOException;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Hook\PermissionFilter;
+use Utopia\Database\Query;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Query\CursorDirection;
+use Utopia\Query\OrderDirection;
+
+final class PostgresQueryBehaviorTest extends TestCase
+{
+    public function testPermissionHookFiltersTheRowJsonbColumn(): void
+    {
+        $adapter = new Postgres($this->pdo());
+        $hookFactory = new ReflectionMethod($adapter, 'newPermissionHook');
+        $hook = $hookFactory->invoke($adapter, 'movies', ['any', 'user:1'], 'read', 'document.'.Storage::UID);
+        $this->assertInstanceOf(PermissionFilter::class, $hook);
+        $condition = $hook->filter('ignored');
+
+        $this->assertSame(
+            '("document"."'.Storage::PERMISSIONS.'" @> ?::jsonb OR "document"."'.Storage::PERMISSIONS.'" @> ?::jsonb)',
+            $condition->expression
+        );
+        $this->assertSame(['["read(\\"any\\")"]', '["read(\\"user:1\\")"]'], $condition->bindings);
+    }
+
+    public function testPermissionHookRejectsEmptyRoles(): void
+    {
+        $adapter = new Postgres($this->pdo());
+        $hookFactory = new ReflectionMethod($adapter, 'newPermissionHook');
+        $hook = $hookFactory->invoke($adapter, 'movies', []);
+        $this->assertInstanceOf(PermissionFilter::class, $hook);
+
+        $this->assertSame('1 = 0', $hook->filter('ignored')->expression);
+        $this->assertSame([], $hook->filter('ignored')->bindings);
+    }
+
+    public function testCreateCollectionStoresJsonbPermissionsWithGinIndex(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->exactly(2))
+            ->method('execute')
+            ->willReturn(true);
+
+        $queries = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('prepare')
+            ->willReturnCallback(function (string $sql) use (&$queries, $statement): \PDOStatement {
+                $queries[] = $sql;
+
+                return $statement;
+            });
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $this->assertTrue($adapter->createCollection('movies'));
+        $this->assertStringContainsString('"'.Storage::PERMISSIONS.'" JSONB', $queries[0]);
+        $this->assertStringContainsString('USING GIN ("'.Storage::PERMISSIONS.'")', $queries[0]);
+    }
+
+    public function testVectorDistanceIsProjectedHydratedAndOrderedBeforeTieBreaker(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $bindings = [];
+        $statement->expects($this->exactly(3))
+            ->method('bindValue')
+            ->willReturnCallback(function (int $position, mixed $value, int $type) use (&$bindings): bool {
+                $bindings[] = [$position, $value, $type];
+
+                return true;
+            });
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([[
+            Storage::UID => 'movie',
+            Storage::SEQUENCE => 1,
+            Storage::PERMISSIONS => '[]',
+            Storage::DISTANCE => '0.25',
+        ]]);
+        $statement->expects($this->once())->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $documents = $adapter->find(
+            new Document([Document::ID => 'movies']),
+            [Query::vectorCosine('embedding', [1.0, 0.0, 0.0])],
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc]
+        );
+
+        $this->assertCount(1, $documents);
+        $this->assertSame(0.25, $documents[0]->getAttribute(Document::DISTANCE));
+        $this->assertMatchesRegularExpression('/SELECT \*, .*::text AS "'.Storage::DISTANCE.'"/', $sql);
+        $this->assertStringContainsString('WHERE "table_main"."embedding" IS NOT NULL', $sql);
+        $this->assertMatchesRegularExpression('/ORDER BY .*<=>.*\), "'.Storage::SEQUENCE.'" ASC/', $sql);
+        $this->assertSame([
+            [1, '[1,0,0]', \PDO::PARAM_STR],
+            [2, '[1,0,0]', \PDO::PARAM_STR],
+            [3, 25, \PDO::PARAM_INT],
+        ], $bindings);
+    }
+
+    public function testVectorCursorComparesDistanceBeforeSequenceTieBreaker(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $bindings = [];
+        $statement->method('bindValue')
+            ->willReturnCallback(function (int $position, mixed $value, int $type) use (&$bindings): bool {
+                $bindings[] = [$position, $value, $type];
+
+                return true;
+            });
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([]);
+        $statement->expects($this->once())->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $adapter->find(
+            new Document([Document::ID => 'movies']),
+            [Query::vectorCosine('embedding', [1.0, 0.0, 0.0])],
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+            cursor: [Document::DISTANCE => 0.25, Document::SEQUENCE => 17],
+        );
+
+        $this->assertStringContainsString(
+            '"table_main"."embedding" IS NOT NULL AND ((("table_main"."embedding" <=> ?::vector)) > ? OR ((("table_main"."embedding" <=> ?::vector)) = ? AND "table_main"."'.Storage::SEQUENCE.'" > ?))',
+            $sql,
+        );
+        $this->assertMatchesRegularExpression('/ORDER BY .*<=>.*\), "'.Storage::SEQUENCE.'" ASC/', $sql);
+        $this->assertSame([
+            [1, '[1,0,0]', \PDO::PARAM_STR],
+            [2, '[1,0,0]', \PDO::PARAM_STR],
+            [3, '0.25', \PDO::PARAM_STR],
+            [4, '[1,0,0]', \PDO::PARAM_STR],
+            [5, '0.25', \PDO::PARAM_STR],
+            [6, 17, \PDO::PARAM_INT],
+            [7, '[1,0,0]', \PDO::PARAM_STR],
+            [8, 25, \PDO::PARAM_INT],
+        ], $bindings);
+    }
+
+    public function testVectorCursorBeforeBindsRoundTripDistance(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $bindings = [];
+        $statement->method('bindValue')
+            ->willReturnCallback(function (int $position, mixed $value, int $type) use (&$bindings): bool {
+                $bindings[] = [$position, $value, $type];
+
+                return true;
+            });
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([]);
+        $statement->expects($this->once())->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $distance = 0.015216441182063223;
+        $adapter->find(
+            new Document([Document::ID => 'movies']),
+            [Query::vectorCosine('embedding', [1.0, 0.0, 0.0])],
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+            cursor: [Document::DISTANCE => $distance, Document::SEQUENCE => 17],
+            cursorDirection: CursorDirection::Before,
+        );
+
+        $this->assertStringContainsString(
+            '"table_main"."embedding" IS NOT NULL AND ((("table_main"."embedding" <=> ?::vector)) < ? OR ((("table_main"."embedding" <=> ?::vector)) = ? AND "table_main"."'.Storage::SEQUENCE.'" < ?))',
+            $sql,
+        );
+        $this->assertMatchesRegularExpression('/ORDER BY .*<=>.*\) DESC, "'.Storage::SEQUENCE.'" DESC/', $sql);
+        $this->assertSame(\json_encode($distance, JSON_THROW_ON_ERROR), $bindings[2][1]);
+        $this->assertSame(\json_encode($distance, JSON_THROW_ON_ERROR), $bindings[4][1]);
+    }
+
+    public function testInvalidPowerArgumentIsTranslatedToLimitException(): void
+    {
+        $pdoException = new PDOException('zero raised to a negative power is undefined');
+        $code = new \ReflectionProperty(Exception::class, 'code');
+        $code->setValue($pdoException, '2201F');
+        $pdoException->errorInfo = ['2201F', 7, 'zero raised to a negative power is undefined'];
+
+        $process = new ReflectionMethod(Postgres::class, 'processException');
+        $exception = $process->invoke(new Postgres($this->pdo()), $pdoException);
+
+        $this->assertInstanceOf(LimitException::class, $exception);
+        $this->assertSame($pdoException, $exception->getPrevious());
+    }
+
+    private function pdo(): \PDO
+    {
+        return $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+    }
+}
diff --git a/tests/unit/PostgresSpatialCacheTest.php b/tests/unit/PostgresSpatialCacheTest.php
new file mode 100644
index 0000000000..e35e0ee004
--- /dev/null
+++ b/tests/unit/PostgresSpatialCacheTest.php
@@ -0,0 +1,141 @@
+<?php
+
+namespace Tests\Unit;
+
+use PDOException;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use ReflectionProperty;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Attribute;
+use Utopia\Database\Document;
+use Utopia\Query\Schema\ColumnType;
+
+final class PostgresSpatialCacheTest extends TestCase
+{
+    public function testRenameInvalidatesSpatialCacheWhenTypeAlterFails(): void
+    {
+        $rename = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $rename->expects($this->once())
+            ->method('execute')
+            ->willReturn(true);
+
+        $alter = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $alter->expects($this->once())
+            ->method('execute')
+            ->willThrowException(new PDOException('Unable to alter spatial column type'));
+
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('prepare')
+            ->willReturnOnConsecutiveCalls($rename, $alter);
+
+        $adapter = new Postgres($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+
+        $collection = new Document([
+            '$id' => 'locations',
+            'attributes' => [new Document(['$id' => 'position', 'type' => ColumnType::Point->value])],
+        ]);
+        $getSpatialAttributes = new ReflectionMethod($adapter, 'getSpatialAttributes');
+        $this->assertSame(['position'], $getSpatialAttributes->invoke($adapter, $collection));
+
+        try {
+            $adapter->updateAttribute(
+                'locations',
+                Attribute::point(key: 'position'),
+                'coordinates'
+            );
+            $this->fail('Expected the type alteration to fail.');
+        } catch (PDOException $exception) {
+            $this->assertSame('Unable to alter spatial column type', $exception->getMessage());
+        }
+
+        $cache = new ReflectionProperty(SQL::class, 'spatialAttributesCache');
+        $this->assertSame([], $cache->getValue($adapter));
+    }
+
+    public function testSpatialCacheRescansWhenAttributeSetChanges(): void
+    {
+        $adapter = new Postgres($this->createStub(\PDO::class));
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $getSpatialAttributes = new ReflectionMethod($adapter, 'getSpatialAttributes');
+
+        $before = new Document([
+            '$id' => 'places',
+            'attributes' => [new Document(['$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value])],
+        ]);
+        $this->assertSame([], $getSpatialAttributes->invoke($adapter, $before));
+
+        $after = new Document([
+            '$id' => 'places',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value]),
+                new Document(['$id' => 'loc', 'key' => 'loc', 'type' => ColumnType::Point->value]),
+            ],
+        ]);
+        $this->assertSame(['loc'], $getSpatialAttributes->invoke($adapter, $after));
+    }
+
+    public function testSpatialAttributesFromTypedObjectsAndEnums(): void
+    {
+        $adapter = new Postgres($this->createStub(\PDO::class));
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $getSpatialAttributes = new ReflectionMethod($adapter, 'getSpatialAttributes');
+
+        $collection = new Document([
+            '$id' => 'mixed',
+            'attributes' => [
+                Attribute::point(key: 'loc'),
+                new Document(['$id' => 'route', 'key' => 'route', 'type' => ColumnType::Linestring]),
+                ['$id' => 'area', 'key' => 'area', 'type' => ColumnType::Polygon->value],
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value]),
+            ],
+        ]);
+
+        $this->assertSame(['loc', 'route', 'area'], $getSpatialAttributes->invoke($adapter, $collection));
+    }
+
+    public function testSpatialWriteValueDetection(): void
+    {
+        $adapter = new Postgres($this->createStub(\PDO::class));
+        $isSpatialWriteValue = new ReflectionMethod($adapter, 'isSpatialWriteValue');
+        $encodeSpatialWriteValue = new ReflectionMethod($adapter, 'encodeSpatialWriteValue');
+
+        $this->assertTrue($isSpatialWriteValue->invoke($adapter, 'POINT(0 0)'));
+        $this->assertTrue($isSpatialWriteValue->invoke($adapter, [0.0, 0.0]));
+        $this->assertTrue($isSpatialWriteValue->invoke($adapter, [[0.0, 0.0], [1.0, 1.0]]));
+        $this->assertFalse($isSpatialWriteValue->invoke($adapter, 'description'));
+        $this->assertFalse($isSpatialWriteValue->invoke($adapter, ['foo' => 'bar']));
+
+        $this->assertSame('POINT(0 0)', $encodeSpatialWriteValue->invoke($adapter, [0.0, 0.0]));
+        $this->assertSame('POINT(0 0)', $encodeSpatialWriteValue->invoke($adapter, 'POINT(0 0)'));
+    }
+
+    public function testAttributeWidthAcceptsDocumentAndTypedAttributes(): void
+    {
+        $adapter = new Postgres($this->createStub(\PDO::class));
+        $collection = new Document([
+            '$id' => 'export',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value, 'size' => 255, 'array' => false]),
+                new Document(['$id' => 'body', 'key' => 'body', 'type' => ColumnType::MediumText->value, 'size' => 0, 'array' => false]),
+                new Document(['$id' => 'notes', 'key' => 'notes', 'type' => ColumnType::LongText->value, 'size' => 0, 'array' => false]),
+                new Document(['$id' => 'count', 'key' => 'count', 'type' => ColumnType::BigInteger, 'size' => 0, 'array' => false]),
+                Attribute::point(key: 'loc'),
+            ],
+        ]);
+
+        $this->assertGreaterThan(0, $adapter->getAttributeWidth($collection));
+    }
+}
diff --git a/tests/unit/Profiler/QueryProfilerAdvancedTest.php b/tests/unit/Profiler/QueryProfilerAdvancedTest.php
new file mode 100644
index 0000000000..fc0ce0a2c1
--- /dev/null
+++ b/tests/unit/Profiler/QueryProfilerAdvancedTest.php
@@ -0,0 +1,205 @@
+<?php
+
+namespace Tests\Unit\Profiler;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Profiler\QueryLog;
+use Utopia\Database\Profiler\QueryProfiler;
+
+class QueryProfilerAdvancedTest extends TestCase
+{
+    private QueryProfiler $profiler;
+
+    protected function setUp(): void
+    {
+        $this->profiler = new QueryProfiler();
+    }
+
+    public function testBacktraceCaptureWhenEnabled(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->enableBacktrace(true);
+        $this->profiler->log('SELECT 1', [], 1.0);
+
+        $logs = $this->profiler->getLogs();
+        $this->assertCount(1, $logs);
+        $this->assertNotNull($logs[0]->backtrace);
+        $this->assertNotEmpty($logs[0]->backtrace);
+    }
+
+    public function testBacktraceIsNullWhenDisabled(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('SELECT 1', [], 1.0);
+
+        $logs = $this->profiler->getLogs();
+        $this->assertNull($logs[0]->backtrace);
+    }
+
+    public function testEnableBacktraceToggle(): void
+    {
+        $this->profiler->enable();
+
+        $this->profiler->enableBacktrace(true);
+        $this->profiler->log('Q1', [], 1.0);
+        $this->assertNotNull($this->profiler->getLogs()[0]->backtrace);
+
+        $this->profiler->enableBacktrace(false);
+        $this->profiler->log('Q2', [], 1.0);
+        $this->assertNull($this->profiler->getLogs()[1]->backtrace);
+    }
+
+    public function testMultipleSlowQueryCallbacks(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(10.0);
+
+        $received = new class () {
+            public mixed $entry = null;
+        };
+        $this->profiler->onSlowQuery(function ($entry) use ($received) {
+            $received->entry = $entry;
+        });
+
+        $this->profiler->log('fast', [], 5.0);
+        $this->assertEmpty($this->profiler->getSlowQueries());
+
+        $this->profiler->log('slow', [], 20.0);
+        $this->assertInstanceOf(QueryLog::class, $received->entry);
+        $this->assertEquals('slow', $received->entry->query);
+    }
+
+    public function testDetectNPlusOneWithVariedQueryPatterns(): void
+    {
+        $this->profiler->enable();
+
+        for ($i = 0; $i < 10; $i++) {
+            $this->profiler->log("SELECT * FROM users WHERE id = {$i}", [], 1.0);
+        }
+
+        for ($i = 0; $i < 3; $i++) {
+            $this->profiler->log("SELECT * FROM posts WHERE id = {$i}", [], 1.0);
+        }
+
+        $violations = $this->profiler->detectNPlusOne(5);
+        $this->assertNotEmpty($violations);
+
+        $hasUsersPattern = false;
+        foreach ($violations as $pattern => $count) {
+            if ($count >= 10) {
+                $hasUsersPattern = true;
+            }
+        }
+        $this->assertTrue($hasUsersPattern);
+    }
+
+    public function testDetectNPlusOneBelowThresholdReturnsEmpty(): void
+    {
+        $this->profiler->enable();
+
+        $this->profiler->log('SELECT * FROM users WHERE id = 1', [], 1.0);
+        $this->profiler->log('SELECT * FROM users WHERE id = 2', [], 1.0);
+
+        $violations = $this->profiler->detectNPlusOne(5);
+        $this->assertEmpty($violations);
+    }
+
+    public function testGetTotalTimeWithNoLogsReturnsZero(): void
+    {
+        $this->assertEquals(0.0, $this->profiler->getTotalTime());
+    }
+
+    public function testGetSlowQueriesReturnsEmptyWhenNoneExceedThreshold(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(50.0);
+
+        $this->profiler->log('fast1', [], 10.0);
+        $this->profiler->log('fast2', [], 20.0);
+
+        $slow = $this->profiler->getSlowQueries();
+        $this->assertEmpty($slow);
+    }
+
+    public function testLogWithAllParameters(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('SELECT * FROM orders', ['active'], 15.5, 'orders', 'find');
+
+        $logs = $this->profiler->getLogs();
+        $this->assertCount(1, $logs);
+        $this->assertEquals('SELECT * FROM orders', $logs[0]->query);
+        $this->assertEquals(['active'], $logs[0]->bindings);
+        $this->assertEquals(15.5, $logs[0]->durationMs);
+        $this->assertEquals('orders', $logs[0]->collection);
+        $this->assertEquals('find', $logs[0]->operation);
+    }
+
+    public function testResetClearsEverything(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('Q1', [], 10.0);
+        $this->profiler->log('Q2', [], 20.0);
+
+        $this->profiler->reset();
+
+        $this->assertCount(0, $this->profiler->getLogs());
+        $this->assertEquals(0, $this->profiler->getQueryCount());
+        $this->assertEquals(0.0, $this->profiler->getTotalTime());
+        $this->assertEmpty($this->profiler->getSlowQueries());
+    }
+
+    public function testSlowQueryCallbackReceivesQueryLogEntry(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(10.0);
+
+        $received = new class () {
+            public mixed $entry = null;
+        };
+        $this->profiler->onSlowQuery(function ($entry) use ($received) {
+            $received->entry = $entry;
+        });
+
+        $this->profiler->log('SELECT slow', ['param'], 50.0, 'users', 'find');
+
+        $this->assertInstanceOf(QueryLog::class, $received->entry);
+        $this->assertEquals('SELECT slow', $received->entry->query);
+        $this->assertEquals(50.0, $received->entry->durationMs);
+        $this->assertEquals('users', $received->entry->collection);
+    }
+
+    public function testDetectNPlusOneNormalizesQueryParameters(): void
+    {
+        $this->profiler->enable();
+
+        for ($i = 0; $i < 6; $i++) {
+            $this->profiler->log("SELECT * FROM users WHERE name = 'user_{$i}'", [], 1.0);
+        }
+
+        $violations = $this->profiler->detectNPlusOne(5);
+        $this->assertNotEmpty($violations);
+    }
+
+    public function testGetSlowQueriesAtExactThreshold(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(50.0);
+
+        $this->profiler->log('exact', [], 50.0);
+
+        $slow = $this->profiler->getSlowQueries();
+        $this->assertCount(1, $slow);
+    }
+
+    public function testEnabledProfilerLogsTotalTimeCorrectly(): void
+    {
+        $this->profiler->enable();
+
+        $this->profiler->log('Q1', [], 1.5);
+        $this->profiler->log('Q2', [], 2.5);
+        $this->profiler->log('Q3', [], 3.0);
+
+        $this->assertEquals(7.0, $this->profiler->getTotalTime());
+    }
+}
diff --git a/tests/unit/Profiler/QueryProfilerTest.php b/tests/unit/Profiler/QueryProfilerTest.php
new file mode 100644
index 0000000000..c15ece0511
--- /dev/null
+++ b/tests/unit/Profiler/QueryProfilerTest.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace Tests\Unit\Profiler;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Profiler\QueryProfiler;
+
+class QueryProfilerTest extends TestCase
+{
+    private QueryProfiler $profiler;
+
+    protected function setUp(): void
+    {
+        $this->profiler = new QueryProfiler();
+    }
+
+    public function testDisabledByDefault(): void
+    {
+        $this->assertFalse($this->profiler->isEnabled());
+    }
+
+    public function testEnableDisable(): void
+    {
+        $this->profiler->enable();
+        $this->assertTrue($this->profiler->isEnabled());
+
+        $this->profiler->disable();
+        $this->assertFalse($this->profiler->isEnabled());
+    }
+
+    public function testLogWhenDisabled(): void
+    {
+        $this->profiler->log('SELECT 1', [], 1.0);
+        $this->assertCount(0, $this->profiler->getLogs());
+    }
+
+    public function testLogWhenEnabled(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('SELECT * FROM users', [], 5.5, 'users', 'find');
+        $this->profiler->log('SELECT * FROM posts', [], 3.2, 'posts', 'find');
+
+        $logs = $this->profiler->getLogs();
+        $this->assertCount(2, $logs);
+        $this->assertEquals('SELECT * FROM users', $logs[0]->query);
+        $this->assertEquals(5.5, $logs[0]->durationMs);
+        $this->assertEquals('users', $logs[0]->collection);
+    }
+
+    public function testQueryCount(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('Q1', [], 1.0);
+        $this->profiler->log('Q2', [], 2.0);
+        $this->profiler->log('Q3', [], 3.0);
+
+        $this->assertEquals(3, $this->profiler->getQueryCount());
+    }
+
+    public function testTotalTime(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('Q1', [], 10.0);
+        $this->profiler->log('Q2', [], 20.0);
+
+        $this->assertEquals(30.0, $this->profiler->getTotalTime());
+    }
+
+    public function testSlowQueryDetection(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(50.0);
+
+        $this->profiler->log('fast', [], 10.0);
+        $this->profiler->log('slow', [], 100.0);
+        $this->profiler->log('medium', [], 49.0);
+
+        $slow = $this->profiler->getSlowQueries();
+        $this->assertCount(1, $slow);
+        $slowEntry = \array_values($slow)[0];
+        $this->assertEquals('slow', $slowEntry->query);
+    }
+
+    public function testSlowQueryCallback(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->setSlowThreshold(50.0);
+
+        $called = new \stdClass();
+        $called->value = false;
+        $this->profiler->onSlowQuery(function () use ($called) {
+            $called->value = true;
+        });
+
+        $this->profiler->log('fast', [], 10.0);
+        $this->assertFalse($called->value);
+
+        $this->profiler->log('slow', [], 100.0);
+        $this->assertTrue($called->value);
+    }
+
+    public function testNPlusOneDetection(): void
+    {
+        $this->profiler->enable();
+
+        for ($i = 0; $i < 10; $i++) {
+            $this->profiler->log('SELECT * FROM users WHERE id = ?', [$i], 1.0);
+        }
+
+        $violations = $this->profiler->detectNPlusOne(5);
+        $this->assertNotEmpty($violations);
+    }
+
+    public function testReset(): void
+    {
+        $this->profiler->enable();
+        $this->profiler->log('Q1', [], 1.0);
+        $this->profiler->reset();
+
+        $this->assertCount(0, $this->profiler->getLogs());
+        $this->assertEquals(0, $this->profiler->getQueryCount());
+    }
+}
diff --git a/tests/unit/QueryCacheTest.php b/tests/unit/QueryCacheTest.php
index 8103a0dd27..4835d0036f 100644
--- a/tests/unit/QueryCacheTest.php
+++ b/tests/unit/QueryCacheTest.php
@@ -6,11 +6,14 @@
 use Utopia\Cache\Adapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 
 class QueryCacheTest extends TestCase
 {
@@ -25,10 +28,16 @@ private function createDatabase(Adapter $cache, array $filters = [], ?DatabaseMe
             ->setNamespace('list_cache_' . \uniqid());
 
         $database->create();
+        $database->getAuthorization()->addRole(Role::any()->toString());
 
         return $database;
     }
 
+    private function withCache(Database $database, string $key, callable $callback): mixed
+    {
+        return $database->withCache($key, $callback);
+    }
+
     /**
      * @param array<Query> $queries
      * @return array<Document>
@@ -40,7 +49,7 @@ private function findWithCache(
         ?string $namespace = null,
     ): array {
         foreach ($queries as $query) {
-            if ($query instanceof Query && $query->getMethod() === Query::TYPE_ORDER_RANDOM) {
+            if ($query->getMethod() === Method::OrderRandom) {
                 return $database->find($collection, $queries);
             }
         }
@@ -71,6 +80,7 @@ function () use (&$callbackCalls): array {
             },
         );
 
+        /** @var mixed $value */
         $this->assertSame(['value' => 'fresh'], $value);
         $this->assertSame(1, $callbackCalls);
 
@@ -82,6 +92,7 @@ function () use (&$callbackCalls): array {
             },
         );
 
+        /** @var mixed $value */
         $this->assertSame(['value' => 'fresh'], $value);
         $this->assertSame(1, $callbackCalls);
     }
@@ -101,6 +112,7 @@ function () use (&$callbackCalls): array {
             },
         );
 
+        /** @var mixed $value */
         $this->assertSame([], $value);
 
         $value = $database->withCache(
@@ -111,6 +123,7 @@ function () use (&$callbackCalls): array {
             },
         );
 
+        /** @var mixed $value */
         $this->assertSame([], $value);
         $this->assertSame(1, $callbackCalls);
     }
@@ -122,7 +135,8 @@ public function testWithCacheCachesNullValues(): void
 
         $callbackCalls = 0;
 
-        $value = $database->withCache(
+        $value = $this->withCache(
+            $database,
             'key',
             function () use (&$callbackCalls): mixed {
                 $callbackCalls++;
@@ -132,9 +146,10 @@ function () use (&$callbackCalls): mixed {
 
         $this->assertNull($value);
 
-        $value = $database->withCache(
+        $value = $this->withCache(
+            $database,
             'key',
-            function () use (&$callbackCalls): string {
+            function () use (&$callbackCalls): mixed {
                 $callbackCalls++;
                 return 'miss';
             },
@@ -179,12 +194,15 @@ function () use (&$firstCalls): array {
             'first-field',
         );
 
+        /** @var mixed $first */
+        /** @var mixed $second */
+        /** @var mixed $cachedFirst */
         $this->assertSame(['value' => 'first'], $first);
         $this->assertSame(['value' => 'second'], $second);
         $this->assertSame(['value' => 'first'], $cachedFirst);
         $this->assertSame(1, $firstCalls);
         $this->assertSame(1, $secondCalls);
-        $this->assertSame(['first-field', 'second-field'], $cache->list('key'));
+        $this->assertSame(3, $cache->getSize());
     }
 
     public function testWithCacheDoesNotCacheFalseValues(): void
@@ -194,9 +212,10 @@ public function testWithCacheDoesNotCacheFalseValues(): void
 
         $callbackCalls = 0;
 
-        $value = $database->withCache(
+        $value = $this->withCache(
+            $database,
             'key',
-            function () use (&$callbackCalls): bool {
+            function () use (&$callbackCalls): mixed {
                 $callbackCalls++;
                 return false;
             },
@@ -213,6 +232,7 @@ function () use (&$callbackCalls): string {
             },
         );
 
+        /** @var mixed $value */
         $this->assertSame('fresh', $value);
         $this->assertSame(2, $callbackCalls);
     }
@@ -241,6 +261,8 @@ public function testWithCacheBypassesCacheForNullHash(): void
             hash: null,
         );
 
+        /** @var mixed $first */
+        /** @var mixed $second */
         $this->assertSame('first', $first);
         $this->assertSame('second', $second);
         $this->assertSame(2, $callbackCalls);
@@ -279,10 +301,10 @@ public function testWithCacheDoesNotCacheMixedDocumentArrays(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', permissions: [
+        $database->createCollection(new Collection(id: 'wafRules', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -315,10 +337,10 @@ public function testWithCacheCachesSingleDocument(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', permissions: [
+        $database->createCollection(new Collection(id: 'wafRules', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -355,9 +377,9 @@ public function testWithCacheCachesStaticQueryValues(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', permissions: [
+        $database->createCollection(new Collection(id: 'wafRules', permissions: [
             Permission::read(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $callbackCalls = 0;
         $collection = $database->getCollection('wafRules');
@@ -381,6 +403,8 @@ public function testWithCacheCachesStaticQueryValues(): void
             hash: $hash,
         );
 
+        /** @var mixed $first */
+        /** @var mixed $second */
         $this->assertSame(10, $first);
         $this->assertSame(10, $second);
         $this->assertSame(1, $callbackCalls);
@@ -390,20 +414,12 @@ public function testQueryCacheUsesCacheUntilPurged(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', [
-            new Document([
-                '$id' => 'projectId',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'wafRules', attributes: [
+            Attribute::string(key: 'projectId'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -443,20 +459,12 @@ public function testQueryCacheSeparatesEntriesByAuthorizationContext(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', [
-            new Document([
-                '$id' => 'projectId',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'wafRules', attributes: [
+            Attribute::string(key: 'projectId'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -489,20 +497,12 @@ public function testQueryCacheRecastsCacheHits(): void
     {
         $cache = new JsonHashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('metrics', [
-            new Document([
-                '$id' => 'value',
-                'type' => Database::VAR_FLOAT,
-                'size' => 0,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'metrics', attributes: [
+            Attribute::double(key: 'value'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('metrics', new Document([
             '$id' => 'metric-a',
@@ -526,26 +526,30 @@ public function testQueryCacheDoesNotDoubleDecodeCustomFilters(): void
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache, [
             'wrapped' => [
-                'encode' => static fn (mixed $value): string => 'encoded:' . $value,
-                'decode' => static fn (mixed $value): string => \str_starts_with((string) $value, 'encoded:')
-                    ? \substr((string) $value, 8)
-                    : 'double:' . $value,
+                'encode' => static function (mixed $value): string {
+                    if (! \is_scalar($value) && $value !== null) {
+                        throw new \InvalidArgumentException('Filter input must be scalar or null');
+                    }
+
+                    return 'encoded:'.(string) $value;
+                },
+                'decode' => static function (mixed $value): string {
+                    if (! \is_string($value)) {
+                        throw new \InvalidArgumentException('Encoded filter input must be a string');
+                    }
+
+                    return \str_starts_with($value, 'encoded:')
+                        ? \substr($value, 8)
+                        : 'double:'.$value;
+                },
             ],
         ]);
-        $database->createCollection('secrets', [
-            new Document([
-                '$id' => 'secret',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => ['wrapped'],
-            ]),
+        $database->createCollection(new Collection(id: 'secrets', attributes: [
+            Attribute::string(key: 'secret', filters: ['wrapped']),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('secrets', new Document([
             '$id' => 'secret-a',
@@ -568,20 +572,12 @@ public function testQueryCacheBypassesCacheForRandomOrder(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', [
-            new Document([
-                '$id' => 'projectId',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'wafRules', attributes: [
+            Attribute::string(key: 'projectId'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -611,19 +607,11 @@ public function testQueryCacheReliesOnPurgeForDocumentSecurityCollections(): voi
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
         $database->getAuthorization()->skip(function () use ($database): void {
-            $database->createCollection('secureRules', [
-                new Document([
-                    '$id' => 'projectId',
-                    'type' => Database::VAR_STRING,
-                    'size' => 255,
-                    'required' => false,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
+            $database->createCollection(new Collection(id: 'secureRules', attributes: [
+                Attribute::string(key: 'projectId'),
             ], permissions: [
                 Permission::create(Role::any()),
-            ], documentSecurity: true);
+            ]));
 
             $database->createDocument('secureRules', new Document([
                 '$id' => 'rule-a',
@@ -670,9 +658,9 @@ public function testQueryCacheFiltersDocumentSecurityPayloadsOnHit(): void
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
         $database->getAuthorization()->skip(function () use ($database): void {
-            $database->createCollection('secureRules', permissions: [
+            $database->createCollection(new Collection(id: 'secureRules', permissions: [
                 Permission::create(Role::any()),
-            ], documentSecurity: true);
+            ]));
         });
 
         $database->getAuthorization()->addRole(Role::user('user-1')->toString());
@@ -680,7 +668,8 @@ public function testQueryCacheFiltersDocumentSecurityPayloadsOnHit(): void
         $collection = $database->getCollection('secureRules');
         $key = $database->getQueryCacheKey($collection->getId(), '_39');
         $hash = $database->getQueryCacheField($collection);
-        $database->getCache()->save($key, [
+        $this->assertNotNull($hash);
+        $this->storeCacheValue($cache, $key, $hash, [
             'collection' => $collection->getId(),
             'type' => 'documents',
             'value' => [
@@ -691,7 +680,7 @@ public function testQueryCacheFiltersDocumentSecurityPayloadsOnHit(): void
                     ],
                 ],
             ],
-        ], $hash);
+        ]);
 
         $callbackCalls = 0;
         $documents = $database->withCache(
@@ -707,6 +696,7 @@ public function testQueryCacheFiltersDocumentSecurityPayloadsOnHit(): void
             hash: $hash,
         );
 
+        /** @var mixed $documents */
         $this->assertSame([], $documents);
         $this->assertSame(0, $callbackCalls);
     }
@@ -715,17 +705,21 @@ public function testQueryCacheRehydratesNestedDocumentPayloads(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('parents', permissions: [
+        $database->createCollection(new Collection(id: 'parents', permissions: [
             Permission::read(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $queries = [
             Query::limit(25),
         ];
 
         $collection = $database->getCollection('parents');
-        $cache->save(
+        $hash = $database->getQueryCacheField($collection, $queries);
+        $this->assertNotNull($hash);
+        $this->storeCacheValue(
+            $cache,
             $database->getQueryCacheKey($collection->getId(), '_39'),
+            $hash,
             [
                 'collection' => $collection->getId(),
                 'type' => 'documents',
@@ -740,34 +734,26 @@ public function testQueryCacheRehydratesNestedDocumentPayloads(): void
                     ],
                 ],
             ],
-            $database->getQueryCacheField($collection, $queries),
         );
 
         $parents = $this->findWithCache($database, 'parents', $queries, '_39');
 
         $this->assertCount(1, $parents);
-        $this->assertInstanceOf(Document::class, $parents[0]->getAttribute('child'));
-        $this->assertSame('child-a', $parents[0]->getAttribute('child')->getId());
+        $child = $parents[0]->getAttribute('child');
+        $this->assertInstanceOf(Document::class, $child);
+        $this->assertSame('child-a', $child->getId());
     }
 
     public function testQueryCacheRefreshesInvalidPayload(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', [
-            new Document([
-                '$id' => 'projectId',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'wafRules', attributes: [
+            Attribute::string(key: 'projectId'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -781,14 +767,17 @@ public function testQueryCacheRefreshesInvalidPayload(): void
         ];
 
         $collection = $database->getCollection('wafRules');
-        $cache->save(
+        $hash = $database->getQueryCacheField($collection, $queries);
+        $this->assertNotNull($hash);
+        $this->storeCacheValue(
+            $cache,
             $database->getQueryCacheKey($collection->getId(), '_39'),
+            $hash,
             [
                 'collection' => $collection->getId(),
                 'type' => 'documents',
                 'value' => 'invalid',
             ],
-            $database->getQueryCacheField($collection, $queries),
         );
 
         $rules = $this->findWithCache($database, 'wafRules', $queries, '_39');
@@ -801,20 +790,12 @@ public function testQueryCacheRefreshesInvalidPayloadEntry(): void
     {
         $cache = new HashMemoryCache();
         $database = $this->createDatabase($cache);
-        $database->createCollection('wafRules', [
-            new Document([
-                '$id' => 'projectId',
-                'type' => Database::VAR_STRING,
-                'size' => 255,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+        $database->createCollection(new Collection(id: 'wafRules', attributes: [
+            Attribute::string(key: 'projectId'),
         ], permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
-        ]);
+        ], documentSecurity: false));
 
         $database->createDocument('wafRules', new Document([
             '$id' => 'rule-a',
@@ -832,8 +813,12 @@ public function testQueryCacheRefreshesInvalidPayloadEntry(): void
         ];
 
         $collection = $database->getCollection('wafRules');
-        $cache->save(
+        $hash = $database->getQueryCacheField($collection, $queries);
+        $this->assertNotNull($hash);
+        $this->storeCacheValue(
+            $cache,
             $database->getQueryCacheKey($collection->getId(), '_39'),
+            $hash,
             [
                 'collection' => $collection->getId(),
                 'type' => 'documents',
@@ -845,7 +830,6 @@ public function testQueryCacheRefreshesInvalidPayloadEntry(): void
                     'invalid',
                 ],
             ],
-            $database->getQueryCacheField($collection, $queries),
         );
 
         $rules = $this->findWithCache($database, 'wafRules', $queries, '_39');
@@ -855,6 +839,14 @@ public function testQueryCacheRefreshesInvalidPayloadEntry(): void
             $rules,
         ));
     }
+
+    /** @param array<string, mixed> $value */
+    private function storeCacheValue(HashMemoryCache $cache, string $key, string $hash, array $value): void
+    {
+        $epoch = 'test-epoch';
+        $cache->save(\strtolower($key.'#epoch'), $epoch);
+        $cache->save(\strtolower($key.'#'.$epoch.':'.$hash), $value);
+    }
 }
 
 class HashMemoryCache implements Adapter
diff --git a/tests/unit/QueryTest.php b/tests/unit/QueryTest.php
index 7d1414c0fb..9eecb446ac 100644
--- a/tests/unit/QueryTest.php
+++ b/tests/unit/QueryTest.php
@@ -6,46 +6,47 @@
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 
 class QueryTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testCreate(): void
+    public function test_create(): void
     {
-        $query = new Query(Query::TYPE_EQUAL, 'title', ['Iron Man']);
+        $query = new Query(Method::Equal, 'title', ['Iron Man']);
 
-        $this->assertEquals(Query::TYPE_EQUAL, $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals('Iron Man', $query->getValues()[0]);
 
-        $query = new Query(Query::TYPE_ORDER_DESC, 'score');
+        $query = new Query(Method::OrderDesc, 'score');
 
-        $this->assertEquals(Query::TYPE_ORDER_DESC, $query->getMethod());
+        $this->assertEquals(Method::OrderDesc, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
-        $query = new Query(Query::TYPE_LIMIT, values: [10]);
+        $query = new Query(Method::Limit, values: [10]);
 
-        $this->assertEquals(Query::TYPE_LIMIT, $query->getMethod());
+        $this->assertEquals(Method::Limit, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
         $this->assertEquals(10, $query->getValues()[0]);
 
         $query = Query::equal('title', ['Iron Man']);
 
-        $this->assertEquals(Query::TYPE_EQUAL, $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals('Iron Man', $query->getValues()[0]);
 
         $query = Query::greaterThan('score', 10);
 
-        $this->assertEquals(Query::TYPE_GREATER, $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals(10, $query->getValues()[0]);
 
@@ -53,275 +54,274 @@ public function testCreate(): void
         $vector = [0.1, 0.2, 0.3];
 
         $query = Query::vectorDot('embedding', $vector);
-        $this->assertEquals(Query::TYPE_VECTOR_DOT, $query->getMethod());
+        $this->assertEquals(Method::VectorDot, $query->getMethod());
         $this->assertEquals('embedding', $query->getAttribute());
         $this->assertEquals([$vector], $query->getValues());
 
         $query = Query::vectorCosine('embedding', $vector);
-        $this->assertEquals(Query::TYPE_VECTOR_COSINE, $query->getMethod());
+        $this->assertEquals(Method::VectorCosine, $query->getMethod());
         $this->assertEquals('embedding', $query->getAttribute());
         $this->assertEquals([$vector], $query->getValues());
 
         $query = Query::vectorEuclidean('embedding', $vector);
-        $this->assertEquals(Query::TYPE_VECTOR_EUCLIDEAN, $query->getMethod());
+        $this->assertEquals(Method::VectorEuclidean, $query->getMethod());
         $this->assertEquals('embedding', $query->getAttribute());
         $this->assertEquals([$vector], $query->getValues());
 
         $query = Query::search('search', 'John Doe');
 
-        $this->assertEquals(Query::TYPE_SEARCH, $query->getMethod());
+        $this->assertEquals(Method::Search, $query->getMethod());
         $this->assertEquals('search', $query->getAttribute());
         $this->assertEquals('John Doe', $query->getValues()[0]);
 
         $query = Query::orderAsc('score');
 
-        $this->assertEquals(Query::TYPE_ORDER_ASC, $query->getMethod());
+        $this->assertEquals(Method::OrderAsc, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
         $query = Query::limit(10);
 
-        $this->assertEquals(Query::TYPE_LIMIT, $query->getMethod());
+        $this->assertEquals(Method::Limit, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
         $this->assertEquals([10], $query->getValues());
 
         $cursor = new Document();
         $query = Query::cursorAfter($cursor);
 
-        $this->assertEquals(Query::TYPE_CURSOR_AFTER, $query->getMethod());
+        $this->assertEquals(Method::CursorAfter, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
         $this->assertEquals([$cursor], $query->getValues());
 
         $query = Query::isNull('title');
 
-        $this->assertEquals(Query::TYPE_IS_NULL, $query->getMethod());
+        $this->assertEquals(Method::IsNull, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
         $query = Query::isNotNull('title');
 
-        $this->assertEquals(Query::TYPE_IS_NOT_NULL, $query->getMethod());
+        $this->assertEquals(Method::IsNotNull, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
         $query = Query::notContains('tags', ['test', 'example']);
 
-        $this->assertEquals(Query::TYPE_NOT_CONTAINS, $query->getMethod());
+        $this->assertEquals(Method::NotContains, $query->getMethod());
         $this->assertEquals('tags', $query->getAttribute());
         $this->assertEquals(['test', 'example'], $query->getValues());
 
         $query = Query::notSearch('content', 'keyword');
 
-        $this->assertEquals(Query::TYPE_NOT_SEARCH, $query->getMethod());
+        $this->assertEquals(Method::NotSearch, $query->getMethod());
         $this->assertEquals('content', $query->getAttribute());
         $this->assertEquals(['keyword'], $query->getValues());
 
         $query = Query::notStartsWith('title', 'prefix');
 
-        $this->assertEquals(Query::TYPE_NOT_STARTS_WITH, $query->getMethod());
+        $this->assertEquals(Method::NotStartsWith, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals(['prefix'], $query->getValues());
 
         $query = Query::notEndsWith('url', '.html');
 
-        $this->assertEquals(Query::TYPE_NOT_ENDS_WITH, $query->getMethod());
+        $this->assertEquals(Method::NotEndsWith, $query->getMethod());
         $this->assertEquals('url', $query->getAttribute());
         $this->assertEquals(['.html'], $query->getValues());
 
         $query = Query::notBetween('score', 10, 20);
 
-        $this->assertEquals(Query::TYPE_NOT_BETWEEN, $query->getMethod());
+        $this->assertEquals(Method::NotBetween, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals([10, 20], $query->getValues());
 
         // Test new date query wrapper methods
         $query = Query::createdBefore('2023-01-01T00:00:00.000Z');
 
-        $this->assertEquals(Query::TYPE_LESSER, $query->getMethod());
+        $this->assertEquals(Method::LessThan, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z'], $query->getValues());
 
         $query = Query::createdAfter('2023-01-01T00:00:00.000Z');
 
-        $this->assertEquals(Query::TYPE_GREATER, $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z'], $query->getValues());
 
         $query = Query::updatedBefore('2023-12-31T23:59:59.999Z');
 
-        $this->assertEquals(Query::TYPE_LESSER, $query->getMethod());
+        $this->assertEquals(Method::LessThan, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::updatedAfter('2023-12-31T23:59:59.999Z');
 
-        $this->assertEquals(Query::TYPE_GREATER, $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::createdBetween('2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z');
 
-        $this->assertEquals(Query::TYPE_BETWEEN, $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::updatedBetween('2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z');
 
-        $this->assertEquals(Query::TYPE_BETWEEN, $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z'], $query->getValues());
 
         // Test orderRandom query
         $query = Query::orderRandom();
-        $this->assertEquals(Query::TYPE_ORDER_RANDOM, $query->getMethod());
+        $this->assertEquals(Method::OrderRandom, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
     }
 
     /**
-     * @return void
      * @throws QueryException
      */
-    public function testParse(): void
+    public function test_parse(): void
     {
         $jsonString = Query::equal('title', ['Iron Man'])->toString();
         $query = Query::parse($jsonString);
         $this->assertEquals('{"method":"equal","attribute":"title","values":["Iron Man"]}', $jsonString);
-        $this->assertEquals('equal', $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals('Iron Man', $query->getValues()[0]);
 
         $query = Query::parse(Query::lessThan('year', 2001)->toString());
-        $this->assertEquals('lessThan', $query->getMethod());
+        $this->assertEquals(Method::LessThan, $query->getMethod());
         $this->assertEquals('year', $query->getAttribute());
         $this->assertEquals(2001, $query->getValues()[0]);
 
         $query = Query::parse(Query::equal('published', [true])->toString());
-        $this->assertEquals('equal', $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('published', $query->getAttribute());
         $this->assertTrue($query->getValues()[0]);
 
         $query = Query::parse(Query::equal('published', [false])->toString());
-        $this->assertEquals('equal', $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('published', $query->getAttribute());
         $this->assertFalse($query->getValues()[0]);
 
         $query = Query::parse(Query::equal('actors', [' Johnny Depp ', ' Brad Pitt', 'Al Pacino '])->toString());
-        $this->assertEquals('equal', $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('actors', $query->getAttribute());
         $this->assertEquals(' Johnny Depp ', $query->getValues()[0]);
         $this->assertEquals(' Brad Pitt', $query->getValues()[1]);
         $this->assertEquals('Al Pacino ', $query->getValues()[2]);
 
         $query = Query::parse(Query::equal('actors', ['Brad Pitt', 'Johnny Depp'])->toString());
-        $this->assertEquals('equal', $query->getMethod());
+        $this->assertEquals(Method::Equal, $query->getMethod());
         $this->assertEquals('actors', $query->getAttribute());
         $this->assertEquals('Brad Pitt', $query->getValues()[0]);
         $this->assertEquals('Johnny Depp', $query->getValues()[1]);
 
         $query = Query::parse(Query::contains('writers', ['Tim O\'Reilly'])->toString());
-        $this->assertEquals('contains', $query->getMethod());
+        $this->assertEquals(Method::Contains, $query->getMethod());
         $this->assertEquals('writers', $query->getAttribute());
         $this->assertEquals('Tim O\'Reilly', $query->getValues()[0]);
 
         $query = Query::parse(Query::greaterThan('score', 8.5)->toString());
-        $this->assertEquals('greaterThan', $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals(8.5, $query->getValues()[0]);
 
         $query = Query::parse(Query::notContains('tags', ['unwanted', 'spam'])->toString());
-        $this->assertEquals('notContains', $query->getMethod());
+        $this->assertEquals(Method::NotContains, $query->getMethod());
         $this->assertEquals('tags', $query->getAttribute());
         $this->assertEquals(['unwanted', 'spam'], $query->getValues());
 
         $query = Query::parse(Query::notSearch('content', 'unwanted content')->toString());
-        $this->assertEquals('notSearch', $query->getMethod());
+        $this->assertEquals(Method::NotSearch, $query->getMethod());
         $this->assertEquals('content', $query->getAttribute());
         $this->assertEquals(['unwanted content'], $query->getValues());
 
         $query = Query::parse(Query::notStartsWith('title', 'temp')->toString());
-        $this->assertEquals('notStartsWith', $query->getMethod());
+        $this->assertEquals(Method::NotStartsWith, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals(['temp'], $query->getValues());
 
         $query = Query::parse(Query::notEndsWith('filename', '.tmp')->toString());
-        $this->assertEquals('notEndsWith', $query->getMethod());
+        $this->assertEquals(Method::NotEndsWith, $query->getMethod());
         $this->assertEquals('filename', $query->getAttribute());
         $this->assertEquals(['.tmp'], $query->getValues());
 
         $query = Query::parse(Query::notBetween('score', 0, 50)->toString());
-        $this->assertEquals('notBetween', $query->getMethod());
+        $this->assertEquals(Method::NotBetween, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals([0, 50], $query->getValues());
 
         $query = Query::parse(Query::notEqual('director', 'null')->toString());
-        $this->assertEquals('notEqual', $query->getMethod());
+        $this->assertEquals(Method::NotEqual, $query->getMethod());
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals('null', $query->getValues()[0]);
 
         $query = Query::parse(Query::isNull('director')->toString());
-        $this->assertEquals('isNull', $query->getMethod());
+        $this->assertEquals(Method::IsNull, $query->getMethod());
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
         $query = Query::parse(Query::isNotNull('director')->toString());
-        $this->assertEquals('isNotNull', $query->getMethod());
+        $this->assertEquals(Method::IsNotNull, $query->getMethod());
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
 
         $query = Query::parse(Query::startsWith('director', 'Quentin')->toString());
-        $this->assertEquals('startsWith', $query->getMethod());
+        $this->assertEquals(Method::StartsWith, $query->getMethod());
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals(['Quentin'], $query->getValues());
 
         $query = Query::parse(Query::endsWith('director', 'Tarantino')->toString());
-        $this->assertEquals('endsWith', $query->getMethod());
+        $this->assertEquals(Method::EndsWith, $query->getMethod());
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals(['Tarantino'], $query->getValues());
 
         $query = Query::parse(Query::select(['title', 'director'])->toString());
-        $this->assertEquals('select', $query->getMethod());
+        $this->assertEquals(Method::Select, $query->getMethod());
         $this->assertEquals(null, $query->getAttribute());
         $this->assertEquals(['title', 'director'], $query->getValues());
 
         // Test new date query wrapper methods parsing
         $query = Query::parse(Query::createdBefore('2023-01-01T00:00:00.000Z')->toString());
-        $this->assertEquals('lessThan', $query->getMethod());
+        $this->assertEquals(Method::LessThan, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z'], $query->getValues());
 
         $query = Query::parse(Query::createdAfter('2023-01-01T00:00:00.000Z')->toString());
-        $this->assertEquals('greaterThan', $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z'], $query->getValues());
 
         $query = Query::parse(Query::updatedBefore('2023-12-31T23:59:59.999Z')->toString());
-        $this->assertEquals('lessThan', $query->getMethod());
+        $this->assertEquals(Method::LessThan, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::parse(Query::updatedAfter('2023-12-31T23:59:59.999Z')->toString());
-        $this->assertEquals('greaterThan', $query->getMethod());
+        $this->assertEquals(Method::GreaterThan, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::parse(Query::createdBetween('2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z')->toString());
-        $this->assertEquals('between', $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('$createdAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::parse(Query::updatedBetween('2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z')->toString());
-        $this->assertEquals('between', $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('$updatedAt', $query->getAttribute());
         $this->assertEquals(['2023-01-01T00:00:00.000Z', '2023-12-31T23:59:59.999Z'], $query->getValues());
 
         $query = Query::parse(Query::between('age', 15, 18)->toString());
-        $this->assertEquals('between', $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('age', $query->getAttribute());
         $this->assertEquals([15, 18], $query->getValues());
 
         $query = Query::parse(Query::between('lastUpdate', 'DATE1', 'DATE2')->toString());
-        $this->assertEquals('between', $query->getMethod());
+        $this->assertEquals(Method::Between, $query->getMethod());
         $this->assertEquals('lastUpdate', $query->getAttribute());
         $this->assertEquals(['DATE1', 'DATE2'], $query->getValues());
 
@@ -347,7 +347,7 @@ public function testParse(): void
 
         $json = Query::or([
             Query::equal('actors', ['Brad Pitt']),
-            Query::equal('actors', ['Johnny Depp'])
+            Query::equal('actors', ['Johnny Depp']),
         ])->toString();
 
         $query = Query::parse($json);
@@ -355,8 +355,8 @@ public function testParse(): void
         /** @var array<Query> $queries */
         $queries = $query->getValues();
         $this->assertCount(2, $query->getValues());
-        $this->assertEquals(Query::TYPE_OR, $query->getMethod());
-        $this->assertEquals(Query::TYPE_EQUAL, $queries[0]->getMethod());
+        $this->assertEquals(Method::Or, $query->getMethod());
+        $this->assertEquals(Method::Equal, $queries[0]->getMethod());
         $this->assertEquals('actors', $queries[0]->getAttribute());
         $this->assertEquals($json, '{"method":"or","values":[{"method":"equal","attribute":"actors","values":["Brad Pitt"]},{"method":"equal","attribute":"actors","values":["Johnny Depp"]}]}');
 
@@ -390,9 +390,16 @@ public function testParse(): void
 
         // Test orderRandom query parsing
         $query = Query::parse(Query::orderRandom()->toString());
-        $this->assertEquals('orderRandom', $query->getMethod());
+        $this->assertEquals(Method::OrderRandom, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
+
+        $query = Query::parse(Query::having([Query::greaterThanEqual('total', 1)])->toString());
+        $this->assertSame(Method::Having, $query->getMethod());
+        $this->assertCount(1, $query->getValues());
+        $this->assertInstanceOf(Query::class, $query->getValues()[0]);
+        $this->assertSame(Method::GreaterThanEqual, $query->getValues()[0]->getMethod());
+        $this->assertSame('total', $query->getValues()[0]->getAttribute());
     }
 
     public function testParseNestedStringValues(): void
@@ -400,7 +407,7 @@ public function testParseNestedStringValues(): void
         // Some clients serialize the children of a logical query as JSON strings
         // rather than nested objects. Parsing must handle that without a TypeError.
         $json = (string) \json_encode([
-            'method' => Query::TYPE_OR,
+            'method' => Method::Or,
             'values' => [
                 Query::equal('actors', ['Brad Pitt'])->toString(),
                 Query::equal('actors', ['Johnny Depp'])->toString(),
@@ -411,25 +418,26 @@ public function testParseNestedStringValues(): void
 
         /** @var array<Query> $queries */
         $queries = $query->getValues();
-        $this->assertEquals(Query::TYPE_OR, $query->getMethod());
+        $this->assertEquals(Method::Or, $query->getMethod());
         $this->assertCount(2, $queries);
-        $this->assertEquals(Query::TYPE_EQUAL, $queries[0]->getMethod());
+        $this->assertEquals(Method::Equal, $queries[0]->getMethod());
         $this->assertEquals('actors', $queries[0]->getAttribute());
         $this->assertEquals(['Brad Pitt'], $queries[0]->getValues());
-        $this->assertEquals(Query::TYPE_EQUAL, $queries[1]->getMethod());
+        $this->assertEquals(Method::Equal, $queries[1]->getMethod());
         $this->assertEquals(['Johnny Depp'], $queries[1]->getValues());
 
         // A nested value that is neither an array nor a string is a clean
         // QueryException, never an uncaught TypeError.
         try {
-            Query::parse((string) \json_encode(['method' => Query::TYPE_OR, 'values' => [123]]));
+            Query::parse((string) \json_encode(['method' => Method::Or, 'values' => [123]]));
             $this->fail('Failed to throw exception');
         } catch (QueryException $e) {
             $this->assertEquals('Invalid nested query. Must be an array or string, got integer', $e->getMessage());
         }
     }
 
-    public function testIsMethod(): void
+
+    public function test_is_method(): void
     {
         $this->assertTrue(Query::isMethod('equal'));
         $this->assertTrue(Query::isMethod('notEqual'));
@@ -460,47 +468,48 @@ public function testIsMethod(): void
         $this->assertTrue(Query::isMethod('or'));
         $this->assertTrue(Query::isMethod('and'));
 
-        $this->assertTrue(Query::isMethod(Query::TYPE_EQUAL));
-        $this->assertTrue(Query::isMethod(Query::TYPE_NOT_EQUAL));
-        $this->assertTrue(Query::isMethod(Query::TYPE_LESSER));
-        $this->assertTrue(Query::isMethod(Query::TYPE_LESSER_EQUAL));
-        $this->assertTrue(Query::isMethod(Query::TYPE_GREATER));
-        $this->assertTrue(Query::isMethod(Query::TYPE_GREATER_EQUAL));
-        $this->assertTrue(Query::isMethod(Query::TYPE_CONTAINS));
-        $this->assertTrue(Query::isMethod(Query::TYPE_NOT_CONTAINS));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_SEARCH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_NOT_SEARCH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_STARTS_WITH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_NOT_STARTS_WITH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_ENDS_WITH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_NOT_ENDS_WITH));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_ORDER_ASC));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_ORDER_DESC));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_LIMIT));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_OFFSET));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_CURSOR_AFTER));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_CURSOR_BEFORE));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_ORDER_RANDOM));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_IS_NULL));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_IS_NOT_NULL));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_BETWEEN));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_NOT_BETWEEN));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_SELECT));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_OR));
-        $this->assertTrue(Query::isMethod(QUERY::TYPE_AND));
+        $this->assertTrue(Query::isMethod(Method::Equal));
+        $this->assertTrue(Query::isMethod(Method::NotEqual));
+        $this->assertTrue(Query::isMethod(Method::LessThan));
+        $this->assertTrue(Query::isMethod(Method::LessThanEqual));
+        $this->assertTrue(Query::isMethod(Method::GreaterThan));
+        $this->assertTrue(Query::isMethod(Method::GreaterThanEqual));
+        $this->assertTrue(Query::isMethod(Method::Contains));
+        $this->assertTrue(Query::isMethod(Method::NotContains));
+        $this->assertTrue(Query::isMethod(Method::Search));
+        $this->assertTrue(Query::isMethod(Method::NotSearch));
+        $this->assertTrue(Query::isMethod(Method::StartsWith));
+        $this->assertTrue(Query::isMethod(Method::NotStartsWith));
+        $this->assertTrue(Query::isMethod(Method::EndsWith));
+        $this->assertTrue(Query::isMethod(Method::NotEndsWith));
+        $this->assertTrue(Query::isMethod(Method::OrderAsc));
+        $this->assertTrue(Query::isMethod(Method::OrderDesc));
+        $this->assertTrue(Query::isMethod(Method::Limit));
+        $this->assertTrue(Query::isMethod(Method::Offset));
+        $this->assertTrue(Query::isMethod(Method::CursorAfter));
+        $this->assertTrue(Query::isMethod(Method::CursorBefore));
+        $this->assertTrue(Query::isMethod(Method::OrderRandom));
+        $this->assertTrue(Query::isMethod(Method::IsNull));
+        $this->assertTrue(Query::isMethod(Method::IsNotNull));
+        $this->assertTrue(Query::isMethod(Method::Between));
+        $this->assertTrue(Query::isMethod(Method::NotBetween));
+        $this->assertTrue(Query::isMethod(Method::Select));
+        $this->assertTrue(Query::isMethod(Method::Or));
+        $this->assertTrue(Query::isMethod(Method::And));
 
         $this->assertFalse(Query::isMethod('invalid'));
         $this->assertFalse(Query::isMethod('lte '));
     }
 
-    public function testNewQueryTypesInTypesArray(): void
+    public function test_new_query_types_in_types_array(): void
     {
-        $this->assertContains(Query::TYPE_NOT_CONTAINS, Query::TYPES);
-        $this->assertContains(Query::TYPE_NOT_SEARCH, Query::TYPES);
-        $this->assertContains(Query::TYPE_NOT_STARTS_WITH, Query::TYPES);
-        $this->assertContains(Query::TYPE_NOT_ENDS_WITH, Query::TYPES);
-        $this->assertContains(Query::TYPE_NOT_BETWEEN, Query::TYPES);
-        $this->assertContains(Query::TYPE_ORDER_RANDOM, Query::TYPES);
+        $allMethods = Method::cases();
+        $this->assertContains(Method::NotContains, $allMethods);
+        $this->assertContains(Method::NotSearch, $allMethods);
+        $this->assertContains(Method::NotStartsWith, $allMethods);
+        $this->assertContains(Method::NotEndsWith, $allMethods);
+        $this->assertContains(Method::NotBetween, $allMethods);
+        $this->assertContains(Method::OrderRandom, $allMethods);
     }
 
     public function testFingerprint(): void
@@ -609,4 +618,32 @@ public function testShape(): void
             $deep->shape(),
         );
     }
+
+    public function testShapeKeepsASharedChildUnderEveryParent(): void
+    {
+        // The same Query object under two parents is a DAG, not a cycle, and it
+        // has to be shaped under both. This is why the walk cannot simply skip
+        // a node it has already seen: dropping the second occurrence would
+        // leave the reversed pass shaping a parent before its child.
+        $shared = Query::equal('a', ['x']);
+        $tree = Query::and([$shared, Query::or([$shared, Query::greaterThan('b', 1)])]);
+
+        $this->assertSame('and:(equal:a|or:(equal:a|greaterThan:b))', $tree->shape());
+    }
+
+    public function testShapeRefusesATreeThatWouldExplodeTheWalk(): void
+    {
+        // Each level reuses the level below it twice, so the preorder walk sees
+        // 2^depth nodes from a structure built with 40 public calls. Before the
+        // cap this exhausted memory; a cycle behaves the same way, unbounded.
+        $node = Query::equal('a', ['x']);
+        for ($i = 0; $i < 40; $i++) {
+            $node = Query::and([$node, $node]);
+        }
+
+        $this->expectException(QueryException::class);
+        $this->expectExceptionMessage('Query is too deeply nested to fingerprint');
+
+        $node->shape();
+    }
 }
diff --git a/tests/unit/RelationshipModelTest.php b/tests/unit/RelationshipModelTest.php
new file mode 100644
index 0000000000..98b4fcf52e
--- /dev/null
+++ b/tests/unit/RelationshipModelTest.php
@@ -0,0 +1,479 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use ReflectionParameter;
+use Utopia\Cache\Adapter\None as NoneAdapter;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ForeignKeyAction;
+
+class RelationshipModelTest extends TestCase
+{
+    public function testConstructor(): void
+    {
+        $rel = Relationship::oneToMany(
+            collection: 'posts',
+            relatedCollection: 'comments',
+            twoWay: true,
+            key: 'comments',
+            twoWayKey: 'post',
+            onDelete: ForeignKeyAction::Cascade,
+            side: RelationSide::Parent,
+        );
+
+        $this->assertSame('posts', $rel->collection);
+        $this->assertSame('comments', $rel->relatedCollection);
+        $this->assertSame(RelationType::OneToMany, $rel->type);
+        $this->assertTrue($rel->twoWay);
+        $this->assertSame('comments', $rel->key);
+        $this->assertSame('post', $rel->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Cascade, $rel->onDelete);
+        $this->assertSame(RelationSide::Parent, $rel->side);
+    }
+
+    public function testConstructorDefaults(): void
+    {
+        $rel = Relationship::oneToOne(
+            collection: 'a',
+            relatedCollection: 'b',
+        );
+
+        $this->assertFalse($rel->twoWay);
+        $this->assertSame('', $rel->key);
+        $this->assertSame('', $rel->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Restrict, $rel->onDelete);
+        $this->assertSame(RelationSide::Parent, $rel->side);
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $rel = Relationship::oneToOne(
+            collection: 'users',
+            relatedCollection: 'profiles',
+            twoWay: true,
+            key: 'profile',
+            twoWayKey: 'user',
+            onDelete: ForeignKeyAction::SetNull,
+            side: RelationSide::Parent,
+        );
+
+        $doc = $rel->toDocument();
+
+        $this->assertSame('profiles', $doc->getAttribute('relatedCollection'));
+        $this->assertSame('oneToOne', $doc->getAttribute('relationType'));
+        $this->assertTrue($doc->getAttribute('twoWay'));
+        $this->assertSame('user', $doc->getAttribute('twoWayKey'));
+        $this->assertSame('setNull', $doc->getAttribute('onDelete'));
+        $this->assertSame('parent', $doc->getAttribute('side'));
+    }
+
+    public function testToDocumentDoesNotIncludeCollectionOrKey(): void
+    {
+        $rel = Relationship::manyToMany(
+            collection: 'posts',
+            relatedCollection: 'tags',
+            key: 'tags',
+        );
+
+        $doc = $rel->toDocument();
+
+        $this->assertNull($doc->getAttribute('collection'));
+        $this->assertNull($doc->getAttribute('key'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $attrDoc = new Document([
+            '$id' => 'comments',
+            'key' => 'comments',
+            'type' => 'relationship',
+            'options' => new Document([
+                'relatedCollection' => 'comments',
+                'relationType' => 'oneToMany',
+                'twoWay' => true,
+                'twoWayKey' => 'post',
+                'onDelete' => 'cascade',
+                'side' => 'parent',
+            ]),
+        ]);
+
+        $rel = Relationship::fromDocument('posts', $attrDoc);
+
+        $this->assertSame('posts', $rel->collection);
+        $this->assertSame('comments', $rel->relatedCollection);
+        $this->assertSame(RelationType::OneToMany, $rel->type);
+        $this->assertTrue($rel->twoWay);
+        $this->assertSame('comments', $rel->key);
+        $this->assertSame('post', $rel->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Cascade, $rel->onDelete);
+        $this->assertSame(RelationSide::Parent, $rel->side);
+    }
+
+    public function testFromDocumentWithArrayOptions(): void
+    {
+        $attrDoc = new Document([
+            '$id' => 'author',
+            'key' => 'author',
+            'type' => 'relationship',
+            'options' => [
+                'relatedCollection' => 'users',
+                'relationType' => 'manyToOne',
+                'twoWay' => false,
+                'twoWayKey' => 'posts',
+                'onDelete' => 'restrict',
+                'side' => 'child',
+            ],
+        ]);
+
+        $rel = Relationship::fromDocument('posts', $attrDoc);
+
+        $this->assertSame('users', $rel->relatedCollection);
+        $this->assertSame(RelationType::ManyToOne, $rel->type);
+        $this->assertFalse($rel->twoWay);
+        $this->assertSame(RelationSide::Child, $rel->side);
+    }
+
+    public function testFromDocumentWithMissingOptions(): void
+    {
+        $attrDoc = new Document([
+            '$id' => 'ref',
+            'key' => 'ref',
+            'type' => 'relationship',
+        ]);
+
+        $rel = Relationship::fromDocument('coll', $attrDoc);
+
+        $this->assertSame('coll', $rel->collection);
+        $this->assertSame('', $rel->relatedCollection);
+        $this->assertSame(RelationType::OneToOne, $rel->type);
+        $this->assertFalse($rel->twoWay);
+        $this->assertSame('', $rel->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Restrict, $rel->onDelete);
+        $this->assertSame(RelationSide::Parent, $rel->side);
+    }
+
+    public function testAllRelationTypeValues(): void
+    {
+        $types = [
+            RelationType::OneToOne,
+            RelationType::OneToMany,
+            RelationType::ManyToOne,
+            RelationType::ManyToMany,
+        ];
+
+        foreach ($types as $type) {
+            $attrDoc = new Document([
+                '$id' => 'rel',
+                'key' => 'rel',
+                'options' => [
+                    'relatedCollection' => 'target',
+                    'relationType' => $type->value,
+                ],
+            ]);
+
+            $rel = Relationship::fromDocument('source', $attrDoc);
+            $this->assertSame($type, $rel->type, "Failed for type: {$type->value}");
+        }
+    }
+
+    public function testTwoWayFlag(): void
+    {
+        $twoWay = new Document([
+            '$id' => 'rel',
+            'key' => 'rel',
+            'options' => [
+                'relatedCollection' => 'b',
+                'relationType' => 'oneToOne',
+                'twoWay' => true,
+                'twoWayKey' => 'back',
+            ],
+        ]);
+
+        $rel = Relationship::fromDocument('a', $twoWay);
+        $this->assertTrue($rel->twoWay);
+        $this->assertSame('back', $rel->twoWayKey);
+
+        $oneWay = new Document([
+            '$id' => 'rel',
+            'key' => 'rel',
+            'options' => [
+                'relatedCollection' => 'b',
+                'relationType' => 'oneToOne',
+                'twoWay' => false,
+            ],
+        ]);
+
+        $rel2 = Relationship::fromDocument('a', $oneWay);
+        $this->assertFalse($rel2->twoWay);
+    }
+
+    public function testAllForeignKeyActionValues(): void
+    {
+        $actions = [
+            ForeignKeyAction::Cascade,
+            ForeignKeyAction::SetNull,
+            ForeignKeyAction::SetDefault,
+            ForeignKeyAction::Restrict,
+            ForeignKeyAction::NoAction,
+        ];
+
+        foreach ($actions as $action) {
+            $attrDoc = new Document([
+                '$id' => 'rel',
+                'key' => 'rel',
+                'options' => [
+                    'relatedCollection' => 'target',
+                    'relationType' => 'oneToOne',
+                    'onDelete' => $action->value,
+                ],
+            ]);
+
+            $rel = Relationship::fromDocument('source', $attrDoc);
+            $this->assertSame($action, $rel->onDelete, "Failed for action: {$action->value}");
+        }
+    }
+
+    public function testFromDocumentWithEnumInstances(): void
+    {
+        $attrDoc = new Document([
+            '$id' => 'rel',
+            'key' => 'rel',
+            'options' => [
+                'relatedCollection' => 'target',
+                'relationType' => RelationType::ManyToMany,
+                'onDelete' => ForeignKeyAction::Cascade,
+                'side' => RelationSide::Child,
+            ],
+        ]);
+
+        $rel = Relationship::fromDocument('source', $attrDoc);
+        $this->assertSame(RelationType::ManyToMany, $rel->type);
+        $this->assertSame(ForeignKeyAction::Cascade, $rel->onDelete);
+        $this->assertSame(RelationSide::Child, $rel->side);
+    }
+
+    /**
+     * @return array<string, array{string, RelationType}>
+     */
+    public static function factories(): array
+    {
+        return [
+            'oneToOne' => ['oneToOne', RelationType::OneToOne],
+            'oneToMany' => ['oneToMany', RelationType::OneToMany],
+            'manyToOne' => ['manyToOne', RelationType::ManyToOne],
+            'manyToMany' => ['manyToMany', RelationType::ManyToMany],
+        ];
+    }
+
+    #[DataProvider('factories')]
+    public function testFactorySetsTypeAndDefaults(string $factory, RelationType $type): void
+    {
+        $relationship = Relationship::{$factory}(
+            collection: 'posts',
+            relatedCollection: 'comments',
+        );
+
+        $this->assertInstanceOf(Relationship::class, $relationship);
+        $this->assertSame('posts', $relationship->collection);
+        $this->assertSame('comments', $relationship->relatedCollection);
+        $this->assertSame($type, $relationship->type);
+        $this->assertFalse($relationship->twoWay);
+        $this->assertSame('', $relationship->key);
+        $this->assertSame('', $relationship->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Restrict, $relationship->onDelete);
+        $this->assertSame(RelationSide::Parent, $relationship->side);
+    }
+
+    public function testFactoryOmitsTypeParameter(): void
+    {
+        $names = array_map(
+            static fn (ReflectionParameter $parameter): string => $parameter->getName(),
+            (new ReflectionMethod(Relationship::class, 'oneToOne'))->getParameters(),
+        );
+
+        $this->assertSame(false, in_array('type', $names, true));
+    }
+
+    public function testFactoryForwardsOptionalArguments(): void
+    {
+        $relationship = Relationship::manyToOne(
+            collection: 'reviews',
+            relatedCollection: 'movies',
+            twoWay: true,
+            key: 'movie',
+            twoWayKey: 'reviews',
+            onDelete: ForeignKeyAction::Cascade,
+            side: RelationSide::Child,
+        );
+
+        $this->assertSame(RelationType::ManyToOne, $relationship->type);
+        $this->assertTrue($relationship->twoWay);
+        $this->assertSame('movie', $relationship->key);
+        $this->assertSame('reviews', $relationship->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Cascade, $relationship->onDelete);
+        $this->assertSame(RelationSide::Child, $relationship->side);
+    }
+
+    public function testBaseConstructorWithDynamicType(): void
+    {
+        $type = RelationType::OneToOne;
+        $relationship = new Relationship(
+            collection: 'a',
+            relatedCollection: 'b',
+            type: $type,
+        );
+
+        $this->assertSame(Relationship::class, $relationship::class);
+        $this->assertSame(RelationType::OneToOne, $relationship->type);
+    }
+
+    public function testExtendsDocument(): void
+    {
+        $relationship = Relationship::oneToOne(
+            collection: 'posts',
+            relatedCollection: 'comments',
+            key: 'comments',
+        );
+
+        $this->assertSame('comments', $relationship->getId());
+        $this->assertSame('posts', $relationship->getAttribute('collection'));
+    }
+
+    public function testFromArrayHydratesFlatDocument(): void
+    {
+        $relationship = Relationship::fromArray([
+            '$id' => 'comments',
+            'key' => 'comments',
+            'collection' => 'posts',
+            'relatedCollection' => 'comments',
+            'relationType' => RelationType::OneToMany->value,
+            'twoWay' => true,
+            'twoWayKey' => 'post',
+            'onDelete' => ForeignKeyAction::Cascade->value,
+            'side' => RelationSide::Parent->value,
+        ]);
+
+        $this->assertSame('posts', $relationship->collection);
+        $this->assertSame('comments', $relationship->relatedCollection);
+        $this->assertSame(RelationType::OneToMany, $relationship->type);
+        $this->assertTrue($relationship->twoWay);
+        $this->assertSame('comments', $relationship->key);
+        $this->assertSame('post', $relationship->twoWayKey);
+        $this->assertSame(ForeignKeyAction::Cascade, $relationship->onDelete);
+        $this->assertSame(RelationSide::Parent, $relationship->side);
+    }
+
+    public function testFromArrayHydratesAttributeOptions(): void
+    {
+        $relationship = Relationship::fromArray([
+            '$id' => 'author',
+            'key' => 'author',
+            'collection' => 'posts',
+            'type' => 'relationship',
+            'options' => [
+                'relatedCollection' => 'users',
+                'relationType' => RelationType::ManyToOne->value,
+                'twoWay' => false,
+                'twoWayKey' => 'posts',
+                'onDelete' => ForeignKeyAction::Restrict->value,
+                'side' => RelationSide::Child->value,
+            ],
+        ]);
+
+        $this->assertSame('posts', $relationship->collection);
+        $this->assertSame('users', $relationship->relatedCollection);
+        $this->assertSame(RelationType::ManyToOne, $relationship->type);
+        $this->assertFalse($relationship->twoWay);
+        $this->assertSame('author', $relationship->key);
+        $this->assertSame(RelationSide::Child, $relationship->side);
+    }
+
+    public function testFromArrayRoundtrip(): void
+    {
+        $original = Relationship::manyToMany(
+            collection: 'posts',
+            relatedCollection: 'tags',
+            twoWay: true,
+            key: 'tags',
+            twoWayKey: 'posts',
+            onDelete: ForeignKeyAction::SetNull,
+            side: RelationSide::Parent,
+        );
+
+        $restored = Relationship::fromArray($original->getArrayCopy());
+
+        $this->assertSame($original->collection, $restored->collection);
+        $this->assertSame($original->relatedCollection, $restored->relatedCollection);
+        $this->assertSame($original->type, $restored->type);
+        $this->assertSame($original->twoWay, $restored->twoWay);
+        $this->assertSame($original->key, $restored->key);
+        $this->assertSame($original->twoWayKey, $restored->twoWayKey);
+        $this->assertSame($original->onDelete, $restored->onDelete);
+        $this->assertSame($original->side, $restored->side);
+    }
+
+    public function testSetDocumentTypeAcceptsRelationship(): void
+    {
+        $database = $this->database();
+        $database->setDocumentType('rels', Relationship::class);
+
+        $this->assertSame(Relationship::class, $database->getDocumentType('rels'));
+    }
+
+    public function testCreateDocumentInstanceHydratesRelationship(): void
+    {
+        $database = $this->database();
+        $database->setDocumentType('rels', Relationship::class);
+
+        $document = $this->instantiate($database, 'rels', [
+            '$id' => 'comments',
+            '$collection' => 'rels',
+            'key' => 'comments',
+            'collection' => 'posts',
+            'relatedCollection' => 'comments',
+            'relationType' => RelationType::OneToMany->value,
+            'twoWay' => true,
+            'twoWayKey' => 'post',
+            'onDelete' => ForeignKeyAction::Cascade->value,
+            'side' => RelationSide::Parent->value,
+        ]);
+
+        $this->assertInstanceOf(Relationship::class, $document);
+        $this->assertSame('posts', $document->collection);
+        $this->assertSame('comments', $document->relatedCollection);
+        $this->assertSame(RelationType::OneToMany, $document->type);
+        $this->assertTrue($document->twoWay);
+        $this->assertSame('comments', $document->key);
+        $this->assertSame(ForeignKeyAction::Cascade, $document->onDelete);
+    }
+
+    private function database(): Database
+    {
+        return new Database(
+            $this->createStub(Adapter::class),
+            new Cache(new NoneAdapter()),
+        );
+    }
+
+    /**
+     * @param array<string, mixed> $data
+     */
+    private function instantiate(Database $database, string $collection, array $data): Document
+    {
+        $method = new ReflectionMethod(Database::class, 'createDocumentInstance');
+
+        /** @var Document $document */
+        $document = $method->invoke($database, $collection, $data);
+
+        return $document;
+    }
+}
diff --git a/tests/unit/Relationships/RelationshipValidationTest.php b/tests/unit/Relationships/RelationshipValidationTest.php
new file mode 100644
index 0000000000..a63a8fa79d
--- /dev/null
+++ b/tests/unit/Relationships/RelationshipValidationTest.php
@@ -0,0 +1,730 @@
+<?php
+
+namespace Tests\Unit\Relationships;
+
+use DateTime;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Authorization as AuthorizationException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\NotFound as NotFoundException;
+use Utopia\Database\Exception\Relationship as RelationshipException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Hook\Relationships;
+use Utopia\Database\Operator;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+
+/** @internal */
+abstract class RelationshipsAdapter extends Adapter implements Feature\Relationships
+{
+}
+
+class RelationshipValidationTest extends TestCase
+{
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, string>  $permissions
+     */
+    private function makeCollection(string $id, array $attributes = [], array $permissions = []): Document
+    {
+        if (empty($permissions)) {
+            $permissions = [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ];
+        }
+
+        return new Document([
+            '$id' => $id,
+            '$sequence' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => $permissions,
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param array<Document> $collections
+     * @param array<string, Document> $documents keyed by "collectionId:docId"
+     */
+    private function buildDatabase(array $collections, array $documents = [], bool $withRelationshipHook = false): Database
+    {
+        $sequence = 1;
+        foreach ($documents as $document) {
+            if ($document->getSequence() === null) {
+                $document->setAttribute('$sequence', $sequence++);
+            }
+        }
+
+        $adapter = self::createStub(RelationshipsAdapter::class);
+        $adapter->method('hasFeature')->willReturnCallback(
+            static fn (string $feature): bool => is_a(RelationshipsAdapter::class, $feature, true)
+        );
+        $adapter->method('getSharedTables')->willReturn(false);
+        $adapter->method('getTenant')->willReturn(null);
+        $adapter->method('getTenantPerDocument')->willReturn(false);
+        $adapter->method('getNamespace')->willReturn('');
+        $adapter->method('getIdAttributeType')->willReturn(ColumnType::Integer->value);
+        $adapter->method('getMaxUIDLength')->willReturn(36);
+        $adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $adapter->method('getLimitForString')->willReturn(16777215);
+        $adapter->method('getLimitForInt')->willReturn(2147483647);
+        $adapter->method('getLimitForAttributes')->willReturn(0);
+        $adapter->method('getLimitForIndexes')->willReturn(64);
+        $adapter->method('getMaxIndexLength')->willReturn(768);
+        $adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $adapter->method('getCountOfAttributes')->willReturn(0);
+        $adapter->method('getCountOfIndexes')->willReturn(0);
+        $adapter->method('getAttributeWidth')->willReturn(0);
+        $adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $adapter->method('filter')->willReturnArgument(0);
+        $adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Operators,
+            ]);
+        });
+        $adapter->method('startTransaction')->willReturn(true);
+        $adapter->method('commitTransaction')->willReturn(true);
+        $adapter->method('rollbackTransaction')->willReturn(true);
+        $adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $adapter->method('createDocument')->willReturnArgument(1);
+        $adapter->method('updateDocument')->willReturnArgument(2);
+        $adapter->method('createRelationship')->willReturn(true);
+        $adapter->method('deleteRelationship')->willReturn(true);
+        $adapter->method('updateRelationship')->willReturn(true);
+        $adapter->method('createIndex')->willReturn(true);
+        $adapter->method('deleteIndex')->willReturn(true);
+        $adapter->method('renameIndex')->willReturn(true);
+        $adapter->method('getSequences')->willReturnArgument(1);
+
+        $meta = $this->metaCollection();
+        $colMap = [];
+        foreach ($collections as $col) {
+            $colMap[$col->getId()] = $col;
+        }
+
+        $adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta, $colMap, $documents) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+                if ($col->getId() === Database::METADATA && isset($colMap[$docId])) {
+                    return $colMap[$docId];
+                }
+                $key = $col->getId() . ':' . $docId;
+                if (isset($documents[$key])) {
+                    return $documents[$key];
+                }
+
+                return new Document();
+            }
+        );
+
+        $cache = new Cache(new None());
+        $database = new Database($adapter, $cache);
+        $database->getAuthorization()->addRole(Role::any()->toString());
+
+        if ($withRelationshipHook) {
+            $database->addHook(new Relationships($database));
+        }
+
+        return $database;
+    }
+
+    public function testStructureValidationAfterRelationsAttribute(): void
+    {
+        $relAttr = new Document([
+            '$id' => 'structure_2', 'key' => 'structure_2',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'structure_2',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => false,
+                'twoWayKey' => 'structure_1',
+                'onDelete' => 'restrict',
+                'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('structure_1', [$relAttr]),
+            $this->makeCollection('structure_2'),
+        ]);
+
+        $this->expectException(StructureException::class);
+
+        $db->createDocument('structure_1', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'structure_2' => '100',
+            'name' => 'Frozen',
+        ]));
+    }
+
+    public function testNoChangeUpdateDocumentWithRelationWithoutPermission(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 100, 'required' => false, 'default' => null,
+            'signed' => false, 'array' => false, 'filters' => [],
+        ]);
+
+        $perms = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::delete(Role::any()),
+        ];
+
+        $doc = new Document([
+            '$id' => 'level1',
+            '$collection' => 'level1',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [],
+            'name' => 'Level 1',
+        ]);
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('level1', [$nameAttr], $perms)],
+            ['level1:level1' => $doc]
+        );
+
+        $created = $db->createDocument('level1', new Document([
+            '$id' => 'level1',
+            '$permissions' => [],
+            'name' => 'Level 1',
+        ]));
+
+        $this->expectException(AuthorizationException::class);
+
+        $db->updateDocument('level1', 'level1', $created->setAttribute('name', 'haha'));
+    }
+
+    public function testNoInvalidKeysWithRelationships(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $speciesRelAttr = new Document([
+            '$id' => 'creature', 'key' => 'creature',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'creatures',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => true,
+                'twoWayKey' => 'species',
+                'onDelete' => 'restrict',
+                'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('species', [$nameAttr, $speciesRelAttr]),
+            $this->makeCollection('creatures', [$nameAttr]),
+            $this->makeCollection('characteristics', [$nameAttr]),
+        ]);
+
+        $doc = $db->createDocument('species', new Document([
+            '$id' => ID::custom('1'),
+            '$permissions' => [Permission::read(Role::any())],
+            'name' => 'Canine',
+            'creature' => null,
+        ]));
+
+        $this->assertEquals('1', $doc->getId());
+    }
+
+    public function testEnforceRelationshipPermissions(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $perms = [
+            Permission::read(Role::any()),
+            Permission::update(Role::user('user1')),
+            Permission::delete(Role::user('user2')),
+        ];
+
+        $doc = new Document([
+            '$id' => 'lawn1',
+            '$collection' => 'lawns',
+            '$sequence' => '1',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => $perms,
+            'name' => 'Lawn 1',
+        ]);
+
+        $colPerms = [Permission::create(Role::any()), Permission::read(Role::any())];
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('lawns', [$nameAttr], $colPerms)],
+            ['lawns:lawn1' => $doc]
+        );
+
+        $db->getAuthorization()->cleanRoles();
+        $db->getAuthorization()->addRole(Role::any()->toString());
+
+        try {
+            $db->updateDocument('lawns', 'lawn1', new Document([
+                '$permissions' => $perms,
+                'name' => 'Lawn 1 Updated',
+            ]));
+            $this->fail('Failed to throw exception');
+        } catch (\Exception $e) {
+            $this->assertInstanceOf(AuthorizationException::class, $e);
+        }
+    }
+
+    public function testCreateRelationshipMissingCollection(): void
+    {
+        $db = $this->buildDatabase([]);
+
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Collection not found');
+
+        $db->createRelationship(Relationship::oneToMany(collection: 'missing', relatedCollection: 'missing', twoWay: true));
+    }
+
+    public function testCreateRelationshipMissingRelatedCollection(): void
+    {
+        $db = $this->buildDatabase([$this->makeCollection('test')]);
+
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Related collection not found');
+
+        $db->createRelationship(Relationship::oneToMany(collection: 'test', relatedCollection: 'missing', twoWay: true));
+    }
+
+    public function testCreateDuplicateRelationship(): void
+    {
+        $relAttr = new Document([
+            '$id' => 'test2', 'key' => 'test2',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'test2',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'test1',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('test1', [$relAttr]),
+            $this->makeCollection('test2'),
+        ]);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Attribute already exists');
+
+        $db->createRelationship(Relationship::oneToMany(collection: 'test1', relatedCollection: 'test2', twoWay: true));
+    }
+
+    public function testCreateInvalidRelationship(): void
+    {
+        $this->expectException(\TypeError::class);
+
+        (new \ReflectionClass(Relationship::class))->newInstance('test3', 'test4', 'invalid', true);
+    }
+
+    public function testDeleteMissingRelationship(): void
+    {
+        $db = $this->buildDatabase([$this->makeCollection('test')]);
+
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Relationship not found');
+
+        $db->deleteRelationship('test', 'test2');
+    }
+
+    public function testCreateInvalidIntValueRelationship(): void
+    {
+        $relAttr = new Document([
+            '$id' => 'invalid2', 'key' => 'invalid2',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'invalid2',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => true, 'twoWayKey' => 'invalid1',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('invalid1', [$relAttr]),
+            $this->makeCollection('invalid2'),
+        ], [], true);
+
+        $this->expectException(RelationshipException::class);
+        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
+
+        $db->createDocument('invalid1', new Document([
+            '$id' => ID::unique(),
+            'invalid2' => 10,
+        ]));
+    }
+
+    public function testCreateInvalidObjectValueRelationship(): void
+    {
+        $relAttr = new Document([
+            '$id' => 'invalid2', 'key' => 'invalid2',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'invalid2',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => true, 'twoWayKey' => 'invalid1',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('invalid1', [$relAttr]),
+            $this->makeCollection('invalid2'),
+        ], [], true);
+
+        $this->expectException(RelationshipException::class);
+        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
+
+        $db->createDocument('invalid1', new Document([
+            '$id' => ID::unique(),
+            'invalid2' => new \stdClass(),
+        ]));
+    }
+
+    public function testCreateInvalidArrayIntValueRelationship(): void
+    {
+        $relAttr = new Document([
+            '$id' => 'invalid3', 'key' => 'invalid3',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'invalid2',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'invalid4',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('invalid1', [$relAttr]),
+            $this->makeCollection('invalid2'),
+        ], [], true);
+
+        $this->expectException(RelationshipException::class);
+        $this->expectExceptionMessage('Invalid relationship value. Must be either a document, document ID, or an array of documents or document IDs.');
+
+        $db->createDocument('invalid1', new Document([
+            '$id' => ID::unique(),
+            'invalid3' => [10],
+        ]));
+    }
+
+    public function testCreateEmptyValueRelationship(): void
+    {
+        $o2oRel = new Document([
+            '$id' => 'null2', 'key' => 'null2',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'null2',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => true, 'twoWayKey' => 'null1',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('null1', [$o2oRel]),
+            $this->makeCollection('null2'),
+        ], [], true);
+
+        $doc = $db->createDocument('null1', new Document([
+            '$id' => ID::unique(),
+            'null2' => null,
+        ]));
+
+        $this->assertNull($doc->getAttribute('null2'));
+    }
+
+    public function testUpdateRelationshipToExistingKey(): void
+    {
+        $ownerAttr = new Document([
+            '$id' => 'owner', 'key' => 'owner', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $cakesRelAttr = new Document([
+            '$id' => 'cakes', 'key' => 'cakes',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'cakes',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'oven',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+        $ovenRelAttr = new Document([
+            '$id' => 'oven', 'key' => 'oven',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'ovens',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'cakes',
+                'onDelete' => 'restrict', 'side' => 'child',
+            ],
+        ]);
+
+        $db = $this->buildDatabase([
+            $this->makeCollection('ovens', [$ownerAttr, $cakesRelAttr]),
+            $this->makeCollection('cakes', [$ovenRelAttr]),
+        ]);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Relationship already exists');
+
+        $db->updateRelationship('ovens', 'cakes', newKey: 'owner');
+    }
+
+    public function testOneToOneRelationshipRejectsArrayOperators(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $relAttr = new Document([
+            '$id' => 'profile', 'key' => 'profile',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'profile_o2o',
+                'relationType' => RelationType::OneToOne,
+                'twoWay' => true, 'twoWayKey' => 'user',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'user1', '$collection' => 'user_o2o',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'User 1', 'profile' => null,
+        ]);
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('user_o2o', [$nameAttr, $relAttr]), $this->makeCollection('profile_o2o')],
+            ['user_o2o:user1' => $existingDoc]
+        );
+
+        $this->expectException(StructureException::class);
+        $this->expectExceptionMessage('single-value relationship');
+
+        $db->updateDocument('user_o2o', 'user1', new Document([
+            'profile' => Operator::arrayAppend(['profile2']),
+        ]));
+    }
+
+    public function testOneToManyRelationshipWithArrayOperators(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $relAttr = new Document([
+            '$id' => 'articles', 'key' => 'articles',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'article',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'author',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+        $authorRel = new Document([
+            '$id' => 'author', 'key' => 'author',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'author',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'articles',
+                'onDelete' => 'restrict', 'side' => 'child',
+            ],
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'author1', '$collection' => 'author',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'Author 1', 'articles' => [],
+        ]);
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('author', [$nameAttr, $relAttr]), $this->makeCollection('article', [$authorRel])],
+            ['author:author1' => $existingDoc]
+        );
+
+        $updated = $db->updateDocument('author', 'author1', new Document([
+            'articles' => Operator::arrayAppend(['article2']),
+        ]));
+
+        $this->assertSame('author1', $updated->getId());
+    }
+
+    public function testOneToManyChildSideRejectsArrayOperators(): void
+    {
+        $titleAttr = new Document([
+            '$id' => 'title', 'key' => 'title', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $childRelAttr = new Document([
+            '$id' => 'parent', 'key' => 'parent',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'parent_o2m',
+                'relationType' => RelationType::OneToMany,
+                'twoWay' => true, 'twoWayKey' => 'children',
+                'onDelete' => 'restrict', 'side' => 'child',
+            ],
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'child1', '$collection' => 'child_o2m',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'title' => 'Child 1', 'parent' => null,
+        ]);
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('parent_o2m'), $this->makeCollection('child_o2m', [$titleAttr, $childRelAttr])],
+            ['child_o2m:child1' => $existingDoc]
+        );
+
+        $this->expectException(StructureException::class);
+        $this->expectExceptionMessage('single-value relationship');
+
+        $db->updateDocument('child_o2m', 'child1', new Document([
+            'parent' => Operator::arrayAppend(['parent2']),
+        ]));
+    }
+
+    public function testManyToManyRelationshipWithArrayOperators(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $relAttr = new Document([
+            '$id' => 'books', 'key' => 'books',
+            'type' => ColumnType::Relationship->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+            'options' => [
+                'relatedCollection' => 'book',
+                'relationType' => RelationType::ManyToMany,
+                'twoWay' => true, 'twoWayKey' => 'libraries',
+                'onDelete' => 'restrict', 'side' => 'parent',
+            ],
+        ]);
+
+        $existingDoc = new Document([
+            '$id' => 'library1', '$collection' => 'library',
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
+            'name' => 'Library 1', 'books' => [],
+        ]);
+
+        $db = $this->buildDatabase(
+            [$this->makeCollection('library', [$nameAttr, $relAttr]), $this->makeCollection('book')],
+            ['library:library1' => $existingDoc]
+        );
+
+        $updated = $db->updateDocument('library', 'library1', new Document([
+            'books' => Operator::arrayAppend(['book2']),
+        ]));
+
+        $this->assertSame('library1', $updated->getId());
+    }
+}
diff --git a/tests/unit/RoleTest.php b/tests/unit/RoleTest.php
index 2c1cbee27d..7e32914cce 100644
--- a/tests/unit/RoleTest.php
+++ b/tests/unit/RoleTest.php
@@ -8,7 +8,7 @@
 
 class RoleTest extends TestCase
 {
-    public function testOutputFromString(): void
+    public function test_output_from_string(): void
     {
         $role = Role::parse('any');
         $this->assertEquals('any', $role->getRole());
@@ -66,7 +66,7 @@ public function testOutputFromString(): void
         $this->assertEmpty($role->getDimension());
     }
 
-    public function testInputFromParameters(): void
+    public function test_input_from_parameters(): void
     {
         $role = new Role('any');
         $this->assertEquals('any', $role->toString());
@@ -96,7 +96,7 @@ public function testInputFromParameters(): void
         $this->assertEquals('label:vip', $role->toString());
     }
 
-    public function testInputFromRoles(): void
+    public function test_input_from_roles(): void
     {
         $role = Role::any();
         $this->assertEquals('any', $role->toString());
@@ -126,7 +126,7 @@ public function testInputFromRoles(): void
         $this->assertEquals('label:vip', $role->toString());
     }
 
-    public function testInputFromID(): void
+    public function test_input_from_id(): void
     {
         $role = Role::user(ID::custom('123'));
         $this->assertEquals('user:123', $role->toString());
diff --git a/tests/unit/SQLFindTest.php b/tests/unit/SQLFindTest.php
new file mode 100644
index 0000000000..a29a20e527
--- /dev/null
+++ b/tests/unit/SQLFindTest.php
@@ -0,0 +1,649 @@
+<?php
+
+namespace Tests\Unit;
+
+use Exception;
+use PDOException;
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use ReflectionProperty;
+use Utopia\Database\Adapter\MySQL;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Timeout as TimeoutException;
+use Utopia\Database\Query;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Query\OrderDirection;
+
+#[AllowMockObjectsWithoutExpectations]
+final class SQLFindTest extends TestCase
+{
+    #[DataProvider('paths')]
+    public function testFetchFailureIsTranslatedAndWinsOverCloseFailure(bool $fast): void
+    {
+        $timeout = $this->createTimeoutException();
+        $statement = $this->statement();
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willThrowException($timeout);
+        $statement->expects($this->once())
+            ->method('closeCursor')
+            ->willThrowException(new PDOException('Failed to close cursor'));
+
+        try {
+            $this->find($this->adapter($statement), $fast);
+        } catch (TimeoutException $exception) {
+            $this->assertSame($timeout, $exception->getPrevious());
+
+            return;
+        }
+
+        $this->fail('Expected a timeout exception.');
+    }
+
+    #[DataProvider('paths')]
+    public function testCloseFailureIsTranslated(bool $fast): void
+    {
+        $close = new PDOException('Lost connection while closing cursor');
+        $statement = $this->statement();
+        $statement->expects($this->once())->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([]);
+        $statement->expects($this->once())->method('closeCursor')->willThrowException($close);
+
+        try {
+            $this->find($this->adapter($statement), $fast);
+        } catch (PDOException $exception) {
+            $this->assertSame($close, $exception);
+
+            return;
+        }
+
+        $this->fail('Expected a close cursor exception.');
+    }
+
+    /**
+     * @return iterable<string, array{bool}>
+     */
+    public static function paths(): iterable
+    {
+        yield 'fast path' => [true];
+        yield 'builder path' => [false];
+    }
+
+    public function testJoinDocumentSecurityLookupMatchesRemappedPhysicalIds(): void
+    {
+        $adapter = new MySQL($this->getMockBuilder(\PDO::class)->disableOriginalConstructor()->getMock());
+        $adapter->setDatabase('appwrite');
+        $adapter->setNamespace('_5');
+
+        $method = new ReflectionMethod(MySQL::class, 'joinDocumentSecurityEnabled');
+
+        $map = ['database_1_collection_2' => false];
+        $this->assertFalse($method->invoke($adapter, $map, 'database_1_collection_2'));
+        $this->assertFalse($method->invoke($adapter, $map, 'appwrite._5_database_1_collection_2'));
+        $this->assertFalse($method->invoke($adapter, $map, '_5_database_1_collection_2'));
+
+        $this->assertTrue($method->invoke($adapter, $map, 'database_1_collection_9'));
+        $this->assertTrue($method->invoke($adapter, [], 'appwrite._5_database_1_collection_2'));
+        $this->assertTrue($method->invoke($adapter, ['database_1_collection_2' => true], 'appwrite._5_database_1_collection_2'));
+    }
+
+    public function testJoinWithoutSelectProjectsQualifiedStars(): void
+    {
+        $sql = $this->captureFindSql([
+            Query::leftJoin('orders', '$id', 'customerId'),
+        ]);
+
+        $this->assertQualifiedJoinStars($sql);
+        $this->assertStringContainsString('LEFT JOIN', $sql);
+    }
+
+    public function testNestedJoinOnCompilesPredicatesOntoJoin(): void
+    {
+        $sql = $this->captureFindSql([
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customerId'),
+                Query::equal('ord.status', ['paid']),
+            ]),
+        ]);
+
+        $this->assertQualifiedJoinStars($sql, joinAlias: 'ord');
+        $this->assertStringContainsString('LEFT JOIN', $sql);
+        $this->assertStringContainsString('AS `ord`', $sql);
+        $this->assertMatchesRegularExpression('/ON\s+`table_main`\.`_uid`\s*=\s*`ord`\.`customerId`/i', $sql);
+        $this->assertStringContainsString('`ord`.`status`', $sql);
+        $this->assertDoesNotMatchRegularExpression('/WHERE[\s\S]*`ord`\.`status`/i', $sql);
+    }
+
+    public function testEmulatesFullOuterJoinWithOuterLimit(): void
+    {
+        $sql = $this->captureFindSql(
+            [Query::fullOuterJoin('orders', '$id', 'customerId')],
+            limit: 2,
+        );
+
+        $this->assertEmulatedFullOuterJoin($sql);
+        $this->assertQualifiedJoinStars($sql);
+        $this->assertSame(1, $this->countLimitsAfterUnion($sql), $sql);
+    }
+
+    public function testEmulatesFullOuterJoinOrderByIsUnambiguousAfterUnion(): void
+    {
+        $sql = $this->captureFindSql(
+            [Query::fullOuterJoin('orders', '$id', 'customerId')],
+            limit: 2,
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+        );
+
+        $this->assertEmulatedFullOuterJoin($sql);
+        $this->assertSame(1, $this->countLimitsAfterUnion($sql), $sql);
+        $this->assertUnambiguousUnionOrderBy($sql);
+    }
+
+    public function testEmulatesFullOuterJoinOrderByMatchesProjectedUnionOutput(): void
+    {
+        $sql = $this->captureFindSql(
+            [
+                Query::fullOuterJoin('orders', '$id', 'customerId'),
+                Query::select(['name']),
+            ],
+            limit: 2,
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+        );
+
+        $this->assertEmulatedFullOuterJoin($sql);
+        $this->assertSame(1, $this->countLimitsAfterUnion($sql), $sql);
+        $this->assertUnambiguousUnionOrderBy($sql);
+    }
+
+    public function testEmulatesFullOuterJoinOrderByHandlesMultipleAttributes(): void
+    {
+        $sql = $this->captureFindSql(
+            [Query::fullOuterJoin('orders', '$id', 'customerId')],
+            limit: 2,
+            orderAttributes: ['name', Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc, OrderDirection::Asc],
+        );
+
+        $this->assertEmulatedFullOuterJoin($sql);
+        $this->assertSame(1, $this->countLimitsAfterUnion($sql), $sql);
+        $this->assertUnambiguousUnionOrderBy($sql, expectedTerms: 2);
+    }
+
+    public function testEmulatesFullOuterJoinStripsOrderAliasesFromDocuments(): void
+    {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([
+            [
+                '_uid' => 'doc1',
+                '_id' => 1,
+                '_permissions' => '[]',
+                '_createdAt' => '2020-01-01 00:00:00.000',
+                '_updatedAt' => '2020-01-01 00:00:00.000',
+                'name' => 'Alice',
+                'foj_ord_0' => 1,
+            ],
+        ]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $results = $this->adapter($statement)->find(
+            new Document(['$id' => 'collection']),
+            [Query::fullOuterJoin('orders', '$id', 'customerId')],
+            limit: 1,
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+        );
+
+        $this->assertSame(1, \count($results));
+        $this->assertSame('doc1', $results[0]->getId());
+        $this->assertSame(false, $results[0]->isSet('foj_ord_0'));
+    }
+
+    public function testEmulatesFullOuterJoinRemapsQualifiedUnionColumns(): void
+    {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([
+            [
+                'table_main._uid' => 'doc1',
+                'table_main._id' => '1',
+                'table_main._permissions' => '[]',
+                'table_main._createdAt' => '2020-01-01 00:00:00.000',
+                'table_main._updatedAt' => '2020-01-01 00:00:00.000',
+                'table_main.name' => 'Alice',
+                'orders._uid' => 'order1',
+                'orders._permissions' => '["read"]',
+                'foj_ord_0' => 1,
+            ],
+        ]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $results = $this->adapter($statement)->find(
+            new Document(['$id' => 'collection']),
+            [
+                Query::fullOuterJoin('orders', '$id', 'customerId'),
+                Query::select(['name']),
+            ],
+            limit: 1,
+            orderAttributes: [Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc],
+        );
+
+        $this->assertSame(1, \count($results));
+        $this->assertSame('doc1', $results[0]->getId());
+        $this->assertSame('1', $results[0]->getSequence());
+        $this->assertSame('Alice', $results[0]->getAttribute('name'));
+        $this->assertSame(false, $results[0]->isSet('foj_ord_0'));
+        $this->assertSame(false, $results[0]->isSet('table_main._uid'));
+        $this->assertSame('order1', $results[0]->getAttribute('orders.$id'));
+        $this->assertSame(['read'], $results[0]->getAttribute('orders.$permissions'));
+        $this->assertSame(false, $results[0]->isSet('orders._uid'));
+    }
+
+    public function testRemapRowPreservesSelectedJoinIdentity(): void
+    {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([
+            [
+                '_uid' => 'hm1',
+                '_id' => 1,
+                '_permissions' => '[]',
+                '_createdAt' => '2020-01-01 00:00:00.000',
+                '_updatedAt' => '2020-01-01 00:00:00.000',
+                'name' => 'Main',
+                'alpha.$id' => 'peer-a',
+                'beta.$id' => 'peer-b',
+                'alpha.label' => 'alpha-one',
+                'beta.label' => 'beta-key',
+                'alpha.score' => 11,
+            ],
+        ]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $results = $this->adapter($statement)->find(
+            new Document(['$id' => 'collection']),
+            [
+                Query::join('peers', '$id', 'mainId', '=', 'alpha'),
+                Query::join('peers', 'peerKey', '$id', '=', 'beta'),
+                Query::select(['name', 'alpha.$id', 'beta.$id', 'alpha.label', 'beta.label', 'alpha.score']),
+            ],
+        );
+
+        $this->assertSame(1, \count($results));
+        $this->assertSame('hm1', $results[0]->getId());
+        $this->assertSame('peer-a', $results[0]->getAttribute('alpha.$id'));
+        $this->assertSame('peer-b', $results[0]->getAttribute('beta.$id'));
+        $this->assertSame('alpha-one', $results[0]->getAttribute('alpha.label'));
+        $this->assertSame('beta-key', $results[0]->getAttribute('beta.label'));
+        $this->assertNotSame('peer-a', $results[0]->getId());
+        $this->assertNotSame('peer-b', $results[0]->getId());
+    }
+
+    public function testRemapRowDoesNotCopyJoinIdentityOntoMain(): void
+    {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([
+            [
+                'table_main._uid' => 'hm1',
+                'table_main._id' => '1',
+                'table_main._permissions' => '[]',
+                'table_main._createdAt' => '2020-01-01 00:00:00.000',
+                'table_main._updatedAt' => '2020-01-01 00:00:00.000',
+                'table_main.name' => 'Main',
+                'twin.$id' => 'hm1',
+                'twin.name' => 'Main',
+                'twin.$permissions' => '["read(\"any\")"]',
+            ],
+        ]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $results = $this->adapter($statement)->find(
+            new Document(['$id' => 'collection']),
+            [
+                Query::join('collection', '$id', '$id', '=', 'twin'),
+                Query::select(['name', 'twin.$id', 'twin.name', 'twin.$permissions']),
+            ],
+        );
+
+        $this->assertSame(1, \count($results));
+        $this->assertSame('hm1', $results[0]->getId());
+        $this->assertSame('hm1', $results[0]->getAttribute('twin.$id'));
+        $this->assertSame('Main', $results[0]->getAttribute('twin.name'));
+        $this->assertSame(['read("any")'], $results[0]->getAttribute('twin.$permissions'));
+    }
+
+    public function testRemapRowMapsMainAliasIdentityWhenJoinIdentityIsSelected(): void
+    {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([
+            [
+                'table_main._uid' => '',
+                'table_main._id' => null,
+                'table_main._permissions' => '[]',
+                'table_main._createdAt' => null,
+                'table_main._updatedAt' => null,
+                'table_main.name' => null,
+                'tail.score' => 7,
+            ],
+        ]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $results = $this->adapter($statement)->find(
+            new Document(['$id' => 'collection']),
+            [
+                Query::rightJoin('tail', '$id', 'mainId', '=', 'tail'),
+                Query::select(['name', 'tail.score']),
+            ],
+        );
+
+        $this->assertSame(1, \count($results));
+        $this->assertSame('', $results[0]->getId());
+        $this->assertSame(7, $results[0]->getAttribute('tail.score'));
+    }
+
+    public function testDistinctSelectIdProjectsMainUid(): void
+    {
+        $sql = $this->captureFindSql([
+            Query::distinct(),
+            Query::join('orders', '$id', 'customerId', '=', 'b'),
+            Query::select(['$id', 'name', 'b.label']),
+        ]);
+
+        $this->assertMatchesRegularExpression('/SELECT\s+DISTINCT/i', $sql);
+        $this->assertStringContainsString('`table_main`.`_uid`', $sql);
+        $this->assertStringContainsString('`b`.`label` AS `b.label`', $sql);
+    }
+
+    public function testSelectedJoinIdentityIsProjectedAsQualifiedInternal(): void
+    {
+        $sql = $this->captureFindSql([
+            Query::join('peers', '$id', 'mainId', '=', 'alpha'),
+            Query::select(['name', 'alpha.$id', 'alpha.label']),
+        ]);
+
+        $this->assertStringContainsString('`alpha`.`_uid` AS `alpha._uid`', $sql);
+        $this->assertStringContainsString('`alpha`.`label` AS `alpha.label`', $sql);
+        $this->assertStringNotContainsString('`alpha.$id`', $sql);
+        $this->assertStringContainsString('`table_main`.`_uid`', $sql);
+    }
+
+    public function testJoinSideSearchRelevanceUsesJoinAlias(): void
+    {
+        $sql = $this->captureFindSql([
+            Query::leftJoin('meta', '$id', 'mainId', '=', 'meta'),
+            Query::search('meta.body', 'needle'),
+        ]);
+
+        $this->assertStringContainsString('`meta`.`body`', $sql);
+        $this->assertStringNotContainsString('metabody', $sql);
+        $this->assertStringNotContainsString('`table_main`.`metabody`', $sql);
+    }
+
+    public function testSqliteJoinSideSearchQuotesJoinAlias(): void
+    {
+        $adapter = new SQLite(new \PDO('sqlite::memory:'));
+        $adapter->setNamespace('namespace');
+        $compile = new ReflectionMethod(SQLite::class, 'compileAdapterFilter');
+
+        $compiled = $compile->invoke(
+            $adapter,
+            Query::search('meta.body', 'needle'),
+            'jh_m',
+            Query::DEFAULT_ALIAS,
+        );
+
+        $this->assertIsArray($compiled);
+        $this->assertArrayHasKey('expression', $compiled);
+        $this->assertIsString($compiled['expression']);
+        $expression = $compiled['expression'];
+        $this->assertStringContainsString('`meta`.`body`', $expression);
+        $this->assertStringContainsString('LIKE', $expression);
+        $this->assertStringNotContainsString('metabody', $expression);
+        $this->assertStringNotContainsString('`table_main`.`metabody`', $expression);
+        $this->assertStringNotContainsString(Storage::SEQUENCE, $expression);
+
+        $main = $compile->invoke(
+            $adapter,
+            Query::search('body', 'needle'),
+            'jh_m',
+            Query::DEFAULT_ALIAS,
+        );
+
+        $this->assertIsArray($main);
+        $this->assertArrayHasKey('expression', $main);
+        $this->assertIsString($main['expression']);
+        $this->assertStringContainsString('`table_main`.`body`', $main['expression']);
+    }
+
+    public function testEmulatesFullOuterJoinCursorAfterUsesJoinQualifiedOrder(): void
+    {
+        $sql = $this->captureFindSql(
+            [Query::fullOuterJoin('meta', '$id', 'mainId', '=', 'meta')],
+            limit: 1,
+            orderAttributes: ['meta.score', Document::SEQUENCE],
+            orderTypes: [OrderDirection::Asc, OrderDirection::Asc],
+            cursor: [
+                'meta.score' => 10,
+                Document::SEQUENCE => '5',
+            ],
+        );
+
+        $this->assertEmulatedFullOuterJoin($sql);
+        $this->assertSame(1, $this->countLimitsAfterUnion($sql), $sql);
+        $this->assertUnambiguousUnionOrderBy($sql, expectedTerms: 2);
+        $this->assertGreaterThanOrEqual(2, \preg_match_all('/`meta`\.`score`\s*>/i', $sql));
+        $this->assertDoesNotMatchRegularExpression(
+            '/ORDER BY\s+`score`\b/i',
+            $sql,
+        );
+    }
+
+    public function testQualifyDottedAttributeKeepsNestedObjectPaths(): void
+    {
+        $adapter = new MySQL($this->getMockBuilder(\PDO::class)->disableOriginalConstructor()->getMock());
+        $method = new ReflectionMethod(MySQL::class, 'qualifyDottedAttribute');
+
+        $aliasSet = [
+            Query::DEFAULT_ALIAS => true,
+            'orders' => true,
+        ];
+        $mainAttributes = [
+            'meta.score' => true,
+        ];
+
+        $this->assertSame(
+            'metascore',
+            $method->invoke($adapter, 'meta.score', $aliasSet, $mainAttributes)
+        );
+        $this->assertSame(
+            'orders.email',
+            $method->invoke($adapter, 'orders.email', $aliasSet, $mainAttributes)
+        );
+        $this->assertSame(
+            'orders._uid',
+            $method->invoke($adapter, 'orders.$id', $aliasSet, $mainAttributes)
+        );
+        $this->assertSame(
+            'profile.user.email',
+            $method->invoke($adapter, 'profile.user.email', $aliasSet, $mainAttributes)
+        );
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
+     */
+    private function captureFindSql(
+        array $queries,
+        ?int $limit = 25,
+        array $orderAttributes = [],
+        array $orderTypes = [],
+        array $cursor = [],
+    ): string {
+        $statement = $this->statement();
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetchAll')->willReturn([]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $adapter->find(
+            new Document(['$id' => 'collection']),
+            $queries,
+            limit: $limit,
+            orderAttributes: $orderAttributes,
+            orderTypes: $orderTypes,
+            cursor: $cursor,
+        );
+
+        $this->assertNotSame('', $sql);
+
+        return $sql;
+    }
+
+    private function assertEmulatedFullOuterJoin(string $sql): void
+    {
+        $this->assertStringContainsString('UNION ALL', $sql);
+        $this->assertSame(0, \preg_match_all('/UNION(?! ALL)/i', $sql), $sql);
+        $this->assertStringContainsString('LEFT JOIN', $sql);
+        $this->assertStringContainsString('RIGHT JOIN', $sql);
+        $this->assertStringContainsString('IS NULL', $sql);
+        $this->assertStringNotContainsString('FULL OUTER JOIN', $sql);
+        $this->assertDoesNotMatchRegularExpression('/FROM\s*\(\s*SELECT\s+\*/i', $sql);
+    }
+
+    private function assertQualifiedJoinStars(string $sql, string $quote = '`', string $joinAlias = 'j0'): void
+    {
+        $this->assertStringContainsString($quote.$joinAlias.$quote.'.*', $sql);
+        $this->assertStringContainsString($quote.'table_main'.$quote.'.*', $sql);
+        $this->assertDoesNotMatchRegularExpression('/SELECT\s+\*(?:\s|,|$)/i', $sql);
+    }
+
+    private function countLimitsAfterUnion(string $sql): int
+    {
+        $unionPosition = \stripos($sql, 'UNION');
+        $this->assertNotFalse($unionPosition);
+
+        $limitMatches = \preg_match_all('/\bLIMIT\s+(?:2|\?)/i', $sql, $matches, PREG_OFFSET_CAPTURE);
+        $this->assertNotFalse($limitMatches);
+        foreach ($matches[0] as $match) {
+            $this->assertGreaterThan($unionPosition, $match[1], $sql);
+        }
+
+        return $limitMatches;
+    }
+
+    private function assertUnambiguousUnionOrderBy(string $sql, int $expectedTerms = 1): void
+    {
+        $unionPosition = \stripos($sql, 'UNION');
+        $this->assertNotFalse($unionPosition);
+
+        $afterUnion = \substr($sql, $unionPosition);
+        $this->assertMatchesRegularExpression('/ORDER BY/i', $afterUnion, $sql);
+
+        $this->assertDoesNotMatchRegularExpression(
+            '/ORDER BY\s+`_id`\b/i',
+            $afterUnion,
+            $sql,
+        );
+
+        $aliasMatches = \preg_match_all('/`foj_ord_\d+`/', $afterUnion);
+        $positionalMatches = \preg_match_all('/ORDER BY\s+\d+/i', $afterUnion);
+
+        $this->assertTrue(
+            $aliasMatches >= $expectedTerms || $positionalMatches === 1,
+            $sql,
+        );
+
+        if ($aliasMatches >= $expectedTerms) {
+            $orderByPosition = \stripos($afterUnion, 'ORDER BY');
+            $this->assertNotFalse($orderByPosition);
+            $selectSql = \substr($sql, 0, $unionPosition + $orderByPosition);
+            for ($index = 0; $index < $expectedTerms; $index++) {
+                $this->assertStringContainsString('foj_ord_'.$index, $selectSql, $sql);
+                $this->assertStringContainsString('`foj_ord_'.$index.'`', $afterUnion, $sql);
+            }
+        }
+
+        $this->assertDoesNotMatchRegularExpression(
+            '/ORDER BY\s+`table_main`\.`_id`/i',
+            $afterUnion,
+            $sql,
+        );
+    }
+
+    private function find(MySQL $adapter, bool $fast): void
+    {
+        $adapter->find(
+            new Document(['$id' => 'collection']),
+            $fast ? [] : [Query::equal('title', ['value'])],
+            orderAttributes: ['$sequence'],
+            orderTypes: [OrderDirection::Asc],
+        );
+    }
+
+    private function adapter(\PDOStatement $statement): MySQL
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())->method('prepare')->willReturn($statement);
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        return $adapter;
+    }
+
+    private function statement(): \PDOStatement&MockObject
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->method('bindValue')->willReturn(true);
+
+        return $statement;
+    }
+
+    private function createTimeoutException(): PDOException
+    {
+        $exception = new PDOException('Query execution was interrupted');
+        $code = new ReflectionProperty(Exception::class, 'code');
+        $code->setValue($exception, 'HY000');
+        $exception->errorInfo = ['HY000', 3024, 'Query execution was interrupted'];
+
+        return $exception;
+    }
+}
diff --git a/tests/unit/SQLGetDocumentTest.php b/tests/unit/SQLGetDocumentTest.php
index d938b85d41..0df351483a 100644
--- a/tests/unit/SQLGetDocumentTest.php
+++ b/tests/unit/SQLGetDocumentTest.php
@@ -4,13 +4,19 @@
 
 use Exception;
 use PDOException;
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
 use PHPUnit\Framework\TestCase;
 use ReflectionProperty;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Timeout as TimeoutException;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Query;
+use Utopia\Database\Storage;
+use Utopia\Database\Validator\Authorization;
 
+#[AllowMockObjectsWithoutExpectations]
 final class SQLGetDocumentTest extends TestCase
 {
     public function testTranslatesExecuteTimeoutClosesCursorAndPreservesOriginalWhenCleanupFails(): void
@@ -22,13 +28,13 @@ public function testTranslatesExecuteTimeoutClosesCursorAndPreservesOriginalWhen
             ->getMock();
         $statement->expects($this->once())
             ->method('bindValue')
-            ->with(':_uid', 'document')
+            ->with(':'.Storage::UID, 'document', \PDO::PARAM_STR)
             ->willReturn(true);
         $statement->expects($this->once())
             ->method('execute')
             ->willThrowException($exception);
         $statement->expects($this->never())
-            ->method('fetchAll');
+            ->method('fetch');
         $statement->expects($this->once())
             ->method('closeCursor')
             ->willThrowException(new PDOException('Failed to close cursor'));
@@ -45,13 +51,13 @@ public function testTranslatesFetchTimeoutAndClosesCursor(): void
             ->getMock();
         $statement->expects($this->once())
             ->method('bindValue')
-            ->with(':_uid', 'document')
+            ->with(':'.Storage::UID, 'document', \PDO::PARAM_STR)
             ->willReturn(true);
         $statement->expects($this->once())
             ->method('execute')
             ->willReturn(true);
         $statement->expects($this->once())
-            ->method('fetchAll')
+            ->method('fetch')
             ->willThrowException($exception);
         $statement->expects($this->once())
             ->method('closeCursor')
@@ -67,14 +73,14 @@ public function testUsesPostgresExecuteHook(): void
             ->getMock();
         $statement->expects($this->once())
             ->method('bindValue')
-            ->with(':_uid', 'document')
+            ->with(':'.Storage::UID, 'document', \PDO::PARAM_STR)
             ->willReturn(true);
         $statement->expects($this->once())
             ->method('execute')
             ->willReturn(true);
         $statement->expects($this->once())
-            ->method('fetchAll')
-            ->willReturn([]);
+            ->method('fetch')
+            ->willReturn(false);
         $statement->expects($this->once())
             ->method('closeCursor')
             ->willReturn(true);
@@ -85,13 +91,14 @@ public function testUsesPostgresExecuteHook(): void
         $pdo->expects($this->once())
             ->method('prepare')
             ->willReturn($statement);
+        $executed = [];
         $pdo->expects($this->exactly(2))
             ->method('exec')
-            ->withConsecutive(
-                ["SET statement_timeout = '25ms'"],
-                ['RESET statement_timeout']
-            )
-            ->willReturnOnConsecutiveCalls(0, 0);
+            ->willReturnCallback(function (string $sql) use (&$executed): int {
+                $executed[] = $sql;
+
+                return 0;
+            });
 
         $adapter = new Postgres($pdo);
         $adapter->setDatabase('database');
@@ -99,18 +106,241 @@ public function testUsesPostgresExecuteHook(): void
         $adapter->setTimeout(25);
 
         $document = $adapter->getDocument(
-            new Document(['$id' => 'collection']),
+            new Document([Document::ID => 'collection']),
             'document'
         );
 
         $this->assertSame([], $document->getArrayCopy());
+        $this->assertSame(["SET statement_timeout = '25ms'", 'RESET statement_timeout'], $executed);
+    }
+
+    public function testTranslatesBuilderFetchTimeoutAndClosesCursor(): void
+    {
+        $exception = $this->createTimeoutException();
+
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->once())
+            ->method('execute')
+            ->willReturn(true);
+        $statement->expects($this->once())
+            ->method('fetchAll')
+            ->willThrowException($exception);
+        $statement->expects($this->once())
+            ->method('closeCursor')
+            ->willReturn(true);
+
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturn($statement);
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+
+        try {
+            $adapter->getDocument(
+                new Document([Document::ID => 'collection']),
+                'document',
+                [Query::select(['title'])]
+            );
+        } catch (TimeoutException $timeout) {
+            $this->assertSame($exception, $timeout->getPrevious());
+
+            return;
+        }
+
+        $this->fail('Expected a timeout exception.');
+    }
+
+    public function testAppliesTypedReadTransformOnFastAndBuilderPaths(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->method('bindValue')->willReturn(true);
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetch')->willReturn(false);
+        $statement->method('fetchAll')->willReturn([]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $queries = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('prepare')
+            ->willReturnCallback(function (string $sql) use (&$queries, $statement): \PDOStatement {
+                $queries[] = $sql;
+
+                return $statement;
+            });
+
+        $events = [];
+        $transform = $this->createMock(Transform::class);
+        $transform->expects($this->exactly(2))
+            ->method('transform')
+            ->willReturnCallback(function (\Utopia\Database\Event $event, string $query) use (&$events): string {
+                $events[] = $event;
+
+                return $query.' /* transformed */';
+            });
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $adapter->addTransform('test', $transform);
+        $collection = new Document([Document::ID => 'collection']);
+
+        $adapter->getDocument($collection, 'fast');
+        $adapter->getDocument($collection, 'builder', [Query::select(['title'])]);
+
+        $this->assertSame([
+            \Utopia\Database\Event::DocumentRead,
+            \Utopia\Database\Event::DocumentRead,
+        ], $events);
+        $this->assertStringEndsWith('/* transformed */', $queries[0]);
+        $this->assertStringEndsWith('/* transformed */', $queries[1]);
+    }
+
+    public function testJoinSkipsFastPath(): void
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->method('bindValue')->willReturn(true);
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetch')->willReturn(false);
+        $statement->method('fetchAll')->willReturn([]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $adapter->getDocument(
+            new Document([Document::ID => 'collection']),
+            'document',
+            [Query::leftJoin('orders', '$id', 'customerId')]
+        );
+
+        $this->assertNotSame('', $sql);
+        $this->assertStringContainsString('JOIN', $sql);
+        $this->assertDoesNotMatchRegularExpression(
+            '/WHERE\s+`_uid`\s*=\s*:_uid\s*$/',
+            $sql
+        );
+        $this->assertQualifiedJoinStars($sql);
+    }
+
+    public function testJoinWithoutSelectProjectsQualifiedStars(): void
+    {
+        $sql = $this->captureGetDocumentSql([
+            Query::leftJoin('orders', '$id', 'customerId'),
+        ]);
+
+        $this->assertQualifiedJoinStars($sql);
+        $this->assertStringContainsString('LEFT JOIN', $sql);
+    }
+
+    public function testJoinAliasWithoutSelectProjectsQualifiedStars(): void
+    {
+        $sql = $this->captureGetDocumentSql([
+            Query::join('orders', '$id', 'customerId', '=', 'rev'),
+        ]);
+
+        $this->assertQualifiedJoinStars($sql, joinAlias: 'rev');
+    }
+
+    public function testGetDocumentFullOuterJoinUsesLeftJoinOnPostgres(): void
+    {
+        $sql = $this->captureGetDocumentSql(
+            [Query::fullOuterJoin('orders', '$id', 'customerId')],
+            postgres: true,
+        );
+
+        $this->assertStringContainsString('LEFT JOIN', $sql);
+        $this->assertStringNotContainsString('FULL OUTER JOIN', $sql);
+        $this->assertStringNotContainsString('UNION ALL', $sql);
+        $this->assertQualifiedJoinStars($sql, '"');
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     */
+    private function captureGetDocumentSql(array $queries, bool $postgres = false): string
+    {
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->method('bindValue')->willReturn(true);
+        $statement->method('execute')->willReturn(true);
+        $statement->method('fetch')->willReturn(false);
+        $statement->method('fetchAll')->willReturn([]);
+        $statement->method('closeCursor')->willReturn(true);
+
+        $sql = '';
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturnCallback(function (string $query) use (&$sql, $statement): \PDOStatement {
+                $sql = $query;
+
+                return $statement;
+            });
+
+        $adapter = $postgres ? new Postgres($pdo) : new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $adapter->getDocument(
+            new Document([Document::ID => 'collection']),
+            'document',
+            $queries
+        );
+
+        $this->assertNotSame('', $sql);
+
+        return $sql;
+    }
+
+    private function assertQualifiedJoinStars(string $sql, string $quote = '`', string $joinAlias = 'j0'): void
+    {
+        $this->assertStringContainsString($quote.$joinAlias.$quote.'.*', $sql);
+        $this->assertStringContainsString($quote.'table_main'.$quote.'.*', $sql);
+        $this->assertDoesNotMatchRegularExpression('/SELECT\s+\*(?:\s|,|$)/i', $sql);
+        $this->assertDoesNotMatchRegularExpression('/FROM\s*\(\s*SELECT\s+\*/i', $sql);
     }
 
     private function assertTimeout(MySQL $adapter, PDOException $exception): void
     {
         try {
             $adapter->getDocument(
-                new Document(['$id' => 'collection']),
+                new Document([Document::ID => 'collection']),
                 'document'
             );
         } catch (TimeoutException $timeout) {
diff --git a/tests/unit/SQLOperatorBindingTest.php b/tests/unit/SQLOperatorBindingTest.php
new file mode 100644
index 0000000000..ef11a609b2
--- /dev/null
+++ b/tests/unit/SQLOperatorBindingTest.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\MySQL;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Operator;
+use Utopia\Database\PDO;
+
+final class SQLOperatorBindingTest extends TestCase
+{
+    /**
+     * @return array<string, array{class-string<SQL>}>
+     */
+    public static function adapterClasses(): array
+    {
+        return [
+            'mysql' => [MySQL::class],
+            'postgres' => [Postgres::class],
+            'sqlite' => [SQLite::class],
+        ];
+    }
+
+    /**
+     * @param class-string<SQL> $adapterClass
+     */
+    #[DataProvider('adapterClasses')]
+    public function testBindsOperatorsToDatabaseStatement(string $adapterClass): void
+    {
+        $connection = new PDO('sqlite::memory:', null, null);
+        $statement = $connection->prepare('SELECT :op_0');
+        $adapter = new $adapterClass($connection);
+        $bindIndex = 0;
+
+        $method = new ReflectionMethod($adapter, 'bindOperatorParams');
+        $method->invokeArgs($adapter, [$statement, Operator::increment(2), &$bindIndex]);
+
+        /** @var mixed $bindIndex */
+        $this->assertSame(1, $bindIndex);
+        $this->assertTrue($statement->execute());
+        $this->assertSame(2, $statement->fetchColumn());
+    }
+}
diff --git a/tests/unit/SQLTimeoutScopeTest.php b/tests/unit/SQLTimeoutScopeTest.php
new file mode 100644
index 0000000000..777884041d
--- /dev/null
+++ b/tests/unit/SQLTimeoutScopeTest.php
@@ -0,0 +1,242 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use ReflectionMethod;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Adapter\MySQL;
+use Utopia\Database\Adapter\Postgres;
+use Utopia\Database\Adapter\SQL;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Change;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Hook\Permissions;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\PDO as DatabasePDO;
+use Utopia\Database\Validator\Authorization;
+
+final class SQLTimeoutScopeTest extends TestCase
+{
+    public function testPublicReadTimeoutDoesNotAffectCollectionDelete(): void
+    {
+        $session = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('exec')
+            ->willReturnCallback(function (string $sql) use (&$session): int {
+                $session[] = $sql;
+
+                return 0;
+            });
+
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->exactly(2))->method('execute')->willReturn(true);
+        $statement->expects($this->once())->method('fetchAll')->willReturn([]);
+        $statement->expects($this->once())->method('closeCursor')->willReturn(true);
+        $pdo->expects($this->exactly(2))->method('prepare')->willReturn($statement);
+
+        $adapter = new MySQL($pdo);
+        $adapter->setDatabase('database');
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+        $adapter->setTimeout(25, Event::DocumentFind);
+
+        $adapter->find(
+            new Document(['$id' => 'movies']),
+            orderAttributes: ['$sequence'],
+        );
+        $this->assertTrue($adapter->deleteCollection('movies'));
+
+        $this->assertSame([
+            'SET SESSION MAX_EXECUTION_TIME = 25',
+            'SET SESSION MAX_EXECUTION_TIME = 0',
+        ], $session);
+    }
+
+    public function testPublicStatementsUseExactBatchSchemaAndPermissionEvents(): void
+    {
+        $transform = new class () implements Transform {
+            /** @var list<Event> */
+            public array $events = [];
+
+            public function transform(Event $event, string $query): string
+            {
+                $this->events[] = $event;
+
+                return $query;
+            }
+        };
+
+        $adapter = new SQLite(new DatabasePDO('sqlite::memory:', null, null));
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+        $adapter->addTransform('events', $transform);
+
+        $this->assertTrue($adapter->createCollection('movies'));
+        $this->assertContains(Event::CollectionCreate, $transform->events);
+        $this->assertNotContains(Event::IndexCreate, $transform->events);
+        $transform->events = [];
+
+        $this->assertTrue($adapter->createAttributes('movies', [
+            Attribute::integer(key: 'score'),
+            Attribute::string(key: 'label', size: 32),
+        ]));
+        $this->assertContains(Event::AttributesCreate, $transform->events);
+        $this->assertNotContains(Event::AttributeCreate, $transform->events);
+        $transform->events = [];
+
+        $collection = new Document(['$id' => 'movies']);
+        $created = new Document(['$id' => 'batch', 'score' => 1, 'label' => 'before', '$permissions' => []]);
+        $adapter->createDocuments($collection, [$created]);
+        $this->assertContains(Event::DocumentsCreate, $transform->events);
+        $this->assertNotContains(Event::DocumentCreate, $transform->events);
+        $created = $adapter->getDocument($collection, 'batch');
+        $updated = new Document([
+            '$id' => 'batch',
+            '$sequence' => $created->getSequence(),
+            'score' => 2,
+            'label' => 'after',
+            '$permissions' => [],
+        ]);
+        $transform->events = [];
+        $adapter->upsertDocuments($collection, '', [new Change($created, $updated)]);
+        $this->assertContains(Event::DocumentsUpsert, $transform->events);
+        $this->assertNotContains(Event::DocumentCreate, $transform->events);
+        $transform->events = [];
+        $adapter->increaseDocumentAttribute('movies', 'batch', 'score', 1, '2026-08-13 00:00:00.000');
+        $adapter->increaseDocumentAttribute('movies', 'batch', 'score', -1, '2026-08-13 00:00:00.000');
+        $this->assertContains(Event::DocumentIncrease, $transform->events);
+        $this->assertContains(Event::DocumentDecrease, $transform->events);
+
+        $adapter->addWriteHook(new Permissions());
+        $permissionDocument = $adapter->createDocument($collection, new Document([
+            '$id' => 'permissioned',
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+        $permissionDocument['$permissions'] = [Permission::read(Role::user('one'))];
+        $adapter->updateDocument($collection, 'permissioned', $permissionDocument, false);
+        $adapter->deleteDocument('movies', 'permissioned');
+
+        foreach ([
+            Event::PermissionsCreate,
+            Event::PermissionsRead,
+            Event::PermissionsDelete,
+        ] as $event) {
+            $this->assertContains($event, $transform->events);
+        }
+    }
+
+    public function testMySQLGlobalTimeoutUsesOnlyTheMySQLSessionVariable(): void
+    {
+        $statements = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('exec')
+            ->willReturnCallback(function (string $sql) use (&$statements): int {
+                $statements[] = $sql;
+
+                return 0;
+            });
+
+        $adapter = new MySQL($pdo);
+        $adapter->setTimeout(1000);
+        $adapter->clearTimeout();
+
+        $this->assertSame([
+            'SET SESSION MAX_EXECUTION_TIME = 1000',
+            'SET SESSION MAX_EXECUTION_TIME = 0',
+        ], $statements);
+    }
+
+    public function testClearingOneScopePreservesTheGlobalTimeout(): void
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))->method('exec')->willReturn(0);
+
+        $adapter = new MariaDB($pdo);
+        $adapter->setTimeout(1000);
+        $adapter->setTimeout(25, Event::DocumentFind);
+
+        $this->assertSame(25, $adapter->getTimeout(Event::DocumentFind));
+        $this->assertSame(1000, $adapter->getTimeout(Event::DocumentCreate));
+
+        $adapter->clearTimeout(Event::DocumentFind);
+
+        $this->assertSame(1000, $adapter->getTimeout(Event::DocumentFind));
+        $this->assertSame(1000, $adapter->getTimeout(Event::DocumentCreate));
+
+        $adapter->clearTimeout();
+        $this->assertSame(0, $adapter->getTimeout(Event::DocumentFind));
+    }
+
+    /**
+     * @param class-string<SQL&Feature\Timeouts> $adapterClass
+     * @param list<string> $expected
+     */
+    #[DataProvider('adapters')]
+    public function testReadScopeIsAppliedOnlyAroundMatchingOperations(string $adapterClass, array $expected): void
+    {
+        $statements = [];
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->exactly(2))
+            ->method('exec')
+            ->willReturnCallback(function (string $sql) use (&$statements): int {
+                $statements[] = $sql;
+
+                return 0;
+            });
+
+        $statement = $this->getMockBuilder(\PDOStatement::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $statement->expects($this->exactly(2))->method('execute')->willReturn(true);
+
+        $adapter = new $adapterClass($pdo);
+        $adapter->setTimeout(25, Event::DocumentFind);
+        $execute = new ReflectionMethod($adapter, 'execute');
+
+        $this->assertTrue($execute->invoke($adapter, $statement, Event::DocumentFind));
+        $this->assertTrue($execute->invoke($adapter, $statement, Event::DocumentCreate));
+        $this->assertSame($expected, $statements);
+    }
+
+    /**
+     * @return iterable<string, array{class-string<SQL&Feature\Timeouts>, list<string>}>
+     */
+    public static function adapters(): iterable
+    {
+        yield 'MariaDB' => [MariaDB::class, [
+            'SET max_statement_time = 0.025000',
+            'SET max_statement_time = 0.000000',
+        ]];
+        yield 'MySQL' => [MySQL::class, [
+            'SET SESSION MAX_EXECUTION_TIME = 25',
+            'SET SESSION MAX_EXECUTION_TIME = 0',
+        ]];
+        yield 'PostgreSQL' => [Postgres::class, [
+            "SET statement_timeout = '25ms'",
+            'RESET statement_timeout',
+        ]];
+    }
+}
diff --git a/tests/unit/SQLTransactionTest.php b/tests/unit/SQLTransactionTest.php
index fc4f5667fa..f5817f5947 100644
--- a/tests/unit/SQLTransactionTest.php
+++ b/tests/unit/SQLTransactionTest.php
@@ -5,6 +5,7 @@
 use PDOException;
 use PHPUnit\Framework\TestCase;
 use ReflectionMethod;
+use ReflectionProperty;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Postgres;
 use Utopia\Database\Adapter\SQL;
@@ -83,4 +84,45 @@ public function testPostgresStartTransactionRecoversFromDesyncedRollback(): void
         $this->assertTrue($adapter->startTransaction());
         $this->assertTrue($adapter->inTransaction());
     }
+
+    public function testPostgresStartTransactionPreservesFalseResultFailure(): void
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $pdo->method('inTransaction')->willReturn(true);
+        $pdo->expects($this->once())
+            ->method('rollBack')
+            ->willReturn(true);
+        $pdo->expects($this->once())
+            ->method('beginTransaction')
+            ->willReturn(false);
+
+        $adapter = new Postgres($pdo);
+
+        $this->expectException(TransactionException::class);
+        $this->expectExceptionMessage('Failed to start transaction');
+
+        $adapter->startTransaction();
+    }
+
+    public function testPostgresRollbackPreservesFalseResultFailure(): void
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('rollBack')
+            ->willReturn(false);
+
+        $adapter = new Postgres($pdo);
+        $inTransaction = new ReflectionProperty(SQL::class, 'inTransaction');
+        $inTransaction->setValue($adapter, 1);
+
+        $this->expectException(TransactionException::class);
+        $this->expectExceptionMessage('Failed to rollback transaction');
+
+        $adapter->rollbackTransaction();
+    }
 }
diff --git a/tests/unit/SQLiteOperatorBehaviorTest.php b/tests/unit/SQLiteOperatorBehaviorTest.php
new file mode 100644
index 0000000000..5697d648a0
--- /dev/null
+++ b/tests/unit/SQLiteOperatorBehaviorTest.php
@@ -0,0 +1,87 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Attribute;
+use Utopia\Database\Document;
+use Utopia\Database\Operator;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Query\Schema\ColumnType;
+
+final class SQLiteOperatorBehaviorTest extends TestCase
+{
+    private SQLite $adapter;
+
+    private Document $collection;
+
+    protected function setUp(): void
+    {
+        $this->adapter = new SQLite(new \PDO('sqlite::memory:'));
+        $this->adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $this->adapter->setAuthorization($authorization);
+
+        $this->collection = new Document([
+            '$id' => 'operators',
+            'attributes' => [new Document(['$id' => 'value', 'type' => ColumnType::Double->value])],
+        ]);
+        $this->adapter->createCollection('operators', [
+            Attribute::double(key: 'value'),
+        ]);
+    }
+
+    public function testInclusiveIncrementBoundAppliesExactMaximum(): void
+    {
+        $this->create('increment', 5.0);
+
+        $this->update('increment', Operator::increment(5, 10));
+
+        $this->assertSame(10.0, $this->value('increment'));
+    }
+
+    public function testPowerAboveMaximumLeavesValueUnchanged(): void
+    {
+        $this->create('power', 5.0);
+
+        $this->update('power', Operator::power(3, 100));
+
+        $this->assertSame(5.0, $this->value('power'));
+    }
+
+    public function testFractionalPowerBelowMaximumIsApplied(): void
+    {
+        $this->create('root', 100.0);
+
+        $this->update('root', Operator::power(0.5, 50));
+
+        $this->assertSame(10.0, $this->value('root'));
+    }
+
+    private function create(string $id, float $value): void
+    {
+        $this->adapter->createDocument($this->collection, new Document([
+            '$id' => $id,
+            '$permissions' => [],
+            'value' => $value,
+        ]));
+    }
+
+    private function update(string $id, Operator $operator): void
+    {
+        $this->adapter->updateDocument($this->collection, $id, new Document([
+            '$id' => $id,
+            'value' => $operator,
+        ]), true);
+    }
+
+    private function value(string $id): float
+    {
+        $value = $this->adapter->getDocument($this->collection, $id)->getAttribute('value');
+        $this->assertIsNumeric($value);
+
+        return (float) $value;
+    }
+}
diff --git a/tests/unit/SQLitePrepareTest.php b/tests/unit/SQLitePrepareTest.php
new file mode 100644
index 0000000000..38a57bf479
--- /dev/null
+++ b/tests/unit/SQLitePrepareTest.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\SQLite;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\PDO as DatabasePDO;
+use Utopia\Database\Validator\Authorization;
+
+final class SQLitePrepareTest extends TestCase
+{
+    public function testWrapperBackedCollectionAndDocumentStatementsExecute(): void
+    {
+        $adapter = new SQLite(new DatabasePDO('sqlite::memory:', null, null));
+        $adapter->setNamespace('namespace');
+        $authorization = new Authorization();
+        $authorization->disable();
+        $adapter->setAuthorization($authorization);
+
+        $this->assertTrue($adapter->createCollection('movies'));
+
+        $document = $adapter->createDocument(
+            new Document(['$id' => 'movies']),
+            new Document(['$id' => 'movie', '$permissions' => []]),
+        );
+
+        $this->assertSame('movie', $document->getId());
+        $this->assertSame('movie', $adapter->getDocument(new Document(['$id' => 'movies']), 'movie')->getId());
+    }
+
+    public function testExistsThrowsDatabaseExceptionWhenPrepareReturnsFalse(): void
+    {
+        $pdo = $this->getMockBuilder(\PDO::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $pdo->expects($this->once())
+            ->method('prepare')
+            ->willReturn(false);
+
+        $adapter = new SQLite($pdo);
+        $adapter->setNamespace('namespace');
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Failed to prepare collection existence query');
+
+        $adapter->exists('database', 'movies');
+    }
+}
diff --git a/tests/unit/Schemaless/SchemalessValidationTest.php b/tests/unit/Schemaless/SchemalessValidationTest.php
new file mode 100644
index 0000000000..b32a082152
--- /dev/null
+++ b/tests/unit/Schemaless/SchemalessValidationTest.php
@@ -0,0 +1,265 @@
+<?php
+
+namespace Tests\Unit\Schemaless;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Query\Schema\Order;
+
+class SchemalessValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::TTLIndexes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('createDocuments')->willReturnCallback(function (Document $col, array $docs) {
+            return $docs;
+        });
+        $this->adapter->method('createIndex')->willReturn(true);
+        $this->adapter->method('deleteIndex')->willReturn(true);
+        $this->adapter->method('getSequences')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, Document>  $indexes
+     */
+    private function makeCollection(string $id, array $attributes = [], array $indexes = []): Document
+    {
+        return new Document([
+            '$id' => $id,
+            '$sequence' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $collections
+     */
+    private function setupCollections(array $collections): void
+    {
+        $meta = $this->metaCollection();
+        /** @var array<string, Document> $map */
+        $map = [];
+        foreach ($collections as $col) {
+            $map[$col->getId()] = $col;
+        }
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta, &$map) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+                if ($col->getId() === Database::METADATA && isset($map[$docId])) {
+                    return $map[$docId];
+                }
+
+                return new Document();
+            }
+        );
+
+        // Persist metadata writes back to the map so subsequent reads observe
+        // mutations made by createIndex/createAttribute/etc.
+        $this->adapter->method('updateDocument')->willReturnCallback(
+            function (Document $col, string $docId, Document $document) use (&$map) {
+                if ($col->getId() === Database::METADATA) {
+                    $map[$docId] = $document;
+                }
+
+                return $document;
+            }
+        );
+    }
+
+    public function testSchemalessDocumentInvalidInteralAttributeValidation(): void
+    {
+        $col = $this->makeCollection('schemaless1');
+        $this->setupCollections([$col]);
+
+        try {
+            $docs = [
+                new Document(['$id' => true, 'freeA' => 'doc1']),
+                new Document(['$id' => true, 'freeB' => 'test']),
+                new Document(['$id' => true]),
+            ];
+            $this->database->createDocuments('schemaless1', $docs);
+            $this->fail('Expected StructureException for invalid $id type');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+
+        try {
+            $docs = [
+                new Document(['$createdAt' => true, 'freeA' => 'doc1']),
+                new Document(['$updatedAt' => true, 'freeB' => 'test']),
+                new Document(['$permissions' => 12]),
+            ];
+            $this->database->createDocuments('schemaless1', $docs);
+            $this->fail('Expected StructureException for invalid internal attribute');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+    }
+
+    public function testSchemalessIndexDuplicatePrevention(): void
+    {
+        $col = $this->makeCollection('sl_idx_dup');
+        $this->setupCollections([$col]);
+
+        $this->database->createDocument('sl_idx_dup', new Document([
+            '$id' => 'a',
+            '$permissions' => [Permission::read(Role::any())],
+            'name' => 'x',
+        ]));
+
+        $this->assertTrue($this->database->createIndex(
+            'sl_idx_dup',
+            Index::key(key: 'duplicate', attributes: ['name'], lengths: [0], orders: [Order::Asc])
+        ));
+
+        try {
+            $this->database->createIndex(
+                'sl_idx_dup',
+                Index::key(key: 'duplicate', attributes: ['name'], lengths: [0], orders: [Order::Asc])
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Exception $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
+        }
+    }
+
+    public function testSchemalessInternalAttributes(): void
+    {
+        $col = $this->makeCollection('sl_internal');
+        $this->setupCollections([$col]);
+
+        $doc = $this->database->createDocument('sl_internal', new Document([
+            '$id' => 'i1',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'name' => 'alpha',
+        ]));
+
+        $this->assertEquals('i1', $doc->getId());
+        $this->assertEquals('sl_internal', $doc->getCollection());
+        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        $perms = $doc->getPermissions();
+        $this->assertContains(Permission::read(Role::any()), $perms);
+        $this->assertContains(Permission::update(Role::any()), $perms);
+        $this->assertContains(Permission::delete(Role::any()), $perms);
+    }
+
+    public function testSchemalessTTLIndexDuplicatePrevention(): void
+    {
+        $col = $this->makeCollection('sl_ttl_dup');
+        $this->setupCollections([$col]);
+
+        $this->assertTrue($this->database->createIndex(
+            'sl_ttl_dup',
+            Index::ttl(key: 'idx_ttl_expires', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 3600)
+        ));
+
+        try {
+            $this->database->createIndex(
+                'sl_ttl_dup',
+                Index::ttl(key: 'idx_ttl_expires_duplicate', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 7200)
+            );
+            $this->fail('Expected exception for duplicate TTL index');
+        } catch (\Exception $e) {
+            $this->assertInstanceOf(DatabaseException::class, $e);
+            $this->assertStringContainsString('There can be only one TTL index in a collection', $e->getMessage());
+        }
+    }
+}
diff --git a/tests/unit/SelectFilterSkipTest.php b/tests/unit/SelectFilterSkipTest.php
new file mode 100644
index 0000000000..9a1fbbbf20
--- /dev/null
+++ b/tests/unit/SelectFilterSkipTest.php
@@ -0,0 +1,87 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\Memory as CacheMemory;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+
+class SelectFilterSkipTest extends TestCase
+{
+    public function testFilterNotAppliedWhenAttributeNotSelected(): void
+    {
+        $database = new Database(new DatabaseMemory(), new Cache(new CacheMemory()));
+        $database
+            ->setDatabase('utopiaTests')
+            ->setNamespace('select_filter_'.\uniqid());
+
+        $database->create();
+
+        $calls = new \stdClass();
+        $calls->count = 0;
+        $database->addFilter(
+            'subQueryProbeUnit',
+            fn (mixed $value) => null,
+            function (mixed $value) use ($calls) {
+                $calls->count++;
+
+                return ['fanned', 'out'];
+            }
+        );
+
+        $database->createCollection(new Collection(id: 'filterSelect'));
+        $database->createAttribute('filterSelect', Attribute::string(key: 'plain', size: 128));
+        $database->createAttribute('filterSelect', Attribute::string(key: 'kids', size: 128, filters: ['subQueryProbeUnit']));
+
+        $database->createDocument('filterSelect', new Document([
+            '$id' => 'doc1',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'plain' => 'x',
+        ]));
+
+        $calls->count = 0;
+        $document = $database->getDocument('filterSelect', 'doc1');
+        $this->assertSame(1, $calls->count);
+        $this->assertSame(['fanned', 'out'], $document->getAttribute('kids'));
+
+        $calls->count = 0;
+        $document = $database->getDocument('filterSelect', 'doc1', [Query::select(['$id', 'plain'])]);
+        $this->assertSame(0, $calls->count);
+        $this->assertNull($document->getAttribute('kids'));
+        $this->assertSame('x', $document->getAttribute('plain'));
+
+        $calls->count = 0;
+        $document = $database->getDocument('filterSelect', 'doc1', [Query::select(['$id', 'kids'])]);
+        $this->assertSame(1, $calls->count);
+        $this->assertSame(['fanned', 'out'], $document->getAttribute('kids'));
+
+        $calls->count = 0;
+        $document = $database->getDocument('filterSelect', 'doc1', [Query::select(['*'])]);
+        $this->assertSame(1, $calls->count);
+        $this->assertSame(['fanned', 'out'], $document->getAttribute('kids'));
+
+        $calls->count = 0;
+        $documents = $database->find('filterSelect', [Query::select(['$id', 'plain'])]);
+        $this->assertCount(1, $documents);
+        $this->assertSame(0, $calls->count);
+        $this->assertNull($documents[0]->getAttribute('kids'));
+
+        $calls->count = 0;
+        $documents = $database->find('filterSelect');
+        $this->assertCount(1, $documents);
+        $this->assertSame(1, $calls->count);
+        $this->assertSame(['fanned', 'out'], $documents[0]->getAttribute('kids'));
+    }
+}
diff --git a/tests/unit/SelectProjectionTest.php b/tests/unit/SelectProjectionTest.php
index 262e609e1b..8e516ac62a 100644
--- a/tests/unit/SelectProjectionTest.php
+++ b/tests/unit/SelectProjectionTest.php
@@ -2,16 +2,20 @@
 
 namespace Tests\Unit;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use Utopia\Cache\Adapter\Memory as CacheMemory;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Query\Method;
 
 /**
  * Drives Database::find(), the entry point the HTTP layer calls, rather than the
@@ -34,8 +38,8 @@ protected function setUp(): void
             ->setNamespace('select_' . \uniqid());
 
         $this->database->create();
-        $this->database->createCollection('widgets');
-        $this->database->createAttribute('widgets', 'sku', Database::VAR_STRING, 255, false);
+        $this->database->createCollection(new Collection(id: 'widgets'));
+        $this->database->createAttribute('widgets', Attribute::string(key: 'sku'));
         $this->database->createDocument('widgets', new Document([
             '$id' => 'widget',
             '$permissions' => [Permission::read(Role::any())],
@@ -43,17 +47,14 @@ protected function setUp(): void
         ]));
     }
 
-    /**
-     * @param array<mixed> $values
-     *
-     * @dataProvider malformedSelections
-     */
+    /** @param array<mixed> $values */
+    #[DataProvider('malformedSelections')]
     public function testAMalformedSelectionIsRefusedRatherThanFatal(array $values): void
     {
         $this->expectException(QueryException::class);
         $this->expectExceptionMessage('Attribute selection must be a string, got');
 
-        $this->database->find('widgets', [Query::select($values)]);
+        $this->database->find('widgets', [new Query(Method::Select, values: $values)]);
     }
 
     /**
@@ -74,15 +75,14 @@ public static function malformedSelections(): array
      * catching Exception — as the HTTP layer does — never sees it and returns a 500.
      *
      * @param array<mixed> $values
-     *
-     * @dataProvider malformedSelections
      */
+    #[DataProvider('malformedSelections')]
     public function testTheRefusalIsCatchableAsAnException(array $values): void
     {
         $caught = null;
 
         try {
-            $this->database->find('widgets', [Query::select($values)]);
+            $this->database->find('widgets', [new Query(Method::Select, values: $values)]);
         } catch (\Exception $exception) {
             $caught = $exception;
         }
diff --git a/tests/unit/Spatial/SpatialValidationTest.php b/tests/unit/Spatial/SpatialValidationTest.php
new file mode 100644
index 0000000000..c70e1254e8
--- /dev/null
+++ b/tests/unit/Spatial/SpatialValidationTest.php
@@ -0,0 +1,345 @@
+<?php
+
+namespace Tests\Unit\Spatial;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Index as IndexException;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Exception\Structure as StructureException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
+
+/** @internal */
+abstract class SpatialAdapter extends Adapter implements Feature\Spatial
+{
+}
+
+class SpatialValidationTest extends TestCase
+{
+    private SpatialAdapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(SpatialAdapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createAttribute')->willReturn(true);
+        $this->adapter->method('createIndex')->willReturn(true);
+        $this->adapter->method('deleteIndex')->willReturn(true);
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+        $this->adapter->method('getSequences')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, Document>  $indexes
+     */
+    private function makeCollection(string $id, array $attributes = [], array $indexes = []): Document
+    {
+        return new Document([
+            '$id' => $id,
+            '$sequence' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $collections
+     */
+    private function setupCollections(array $collections): void
+    {
+        $meta = $this->metaCollection();
+        $map = [];
+        foreach ($collections as $col) {
+            $map[$col->getId()] = $col;
+        }
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta, $map) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+                if ($col->getId() === Database::METADATA && isset($map[$docId])) {
+                    return $map[$docId];
+                }
+
+                return new Document();
+            }
+        );
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+    }
+
+    public function testSpatialAttributeDefaults(): void
+    {
+        $ptAttr = new Document([
+            '$id' => 'pt', 'key' => 'pt', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => false, 'default' => [1.0, 2.0],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $lnAttr = new Document([
+            '$id' => 'ln', 'key' => 'ln', 'type' => ColumnType::Linestring->value,
+            'size' => 0, 'required' => false, 'default' => [[0.0, 0.0], [1.0, 1.0]],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $pgAttr = new Document([
+            '$id' => 'pg', 'key' => 'pg', 'type' => ColumnType::Polygon->value,
+            'size' => 0, 'required' => false, 'default' => [[[0.0, 0.0], [0.0, 2.0], [2.0, 2.0], [0.0, 0.0]]],
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('spatial_defaults', [$ptAttr, $lnAttr, $pgAttr]);
+        $this->setupCollections([$col]);
+
+        $doc = $this->database->createDocument('spatial_defaults', new Document([
+            '$id' => ID::custom('d1'),
+            '$permissions' => [Permission::read(Role::any())],
+        ]));
+
+        $this->assertEquals([1.0, 2.0], $doc->getAttribute('pt'));
+        $this->assertEquals([[0.0, 0.0], [1.0, 1.0]], $doc->getAttribute('ln'));
+        $this->assertEquals([[[0.0, 0.0], [0.0, 2.0], [2.0, 2.0], [0.0, 0.0]]], $doc->getAttribute('pg'));
+    }
+
+    public function testInvalidSpatialTypes(): void
+    {
+        $pointAttr = new Document([
+            '$id' => 'pointAttr', 'key' => 'pointAttr', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Point->value],
+        ]);
+        $lineAttr = new Document([
+            '$id' => 'lineAttr', 'key' => 'lineAttr', 'type' => ColumnType::Linestring->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Linestring->value],
+        ]);
+        $polyAttr = new Document([
+            '$id' => 'polyAttr', 'key' => 'polyAttr', 'type' => ColumnType::Polygon->value,
+            'size' => 0, 'required' => false, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Polygon->value],
+        ]);
+
+        $col = $this->makeCollection('test_invalid_spatial', [$pointAttr, $lineAttr, $polyAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('test_invalid_spatial', new Document([
+                'pointAttr' => [10.0],
+            ]));
+            $this->fail('Expected StructureException for invalid point');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+
+        try {
+            $this->database->createDocument('test_invalid_spatial', new Document([
+                'lineAttr' => [[10.0, 20.0]],
+            ]));
+            $this->fail('Expected StructureException for invalid line');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+
+        try {
+            $this->database->createDocument('test_invalid_spatial', new Document([
+                'polyAttr' => [10.0, 20.0],
+            ]));
+            $this->fail('Expected StructureException for invalid polygon');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(StructureException::class, $e);
+        }
+    }
+
+    public function testSpatialDistanceQueryOnNonSpatialAttribute(): void
+    {
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+        $locAttr = new Document([
+            '$id' => 'loc', 'key' => 'loc', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('spatial_distance_error', [$nameAttr, $locAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->find('spatial_distance_error', [
+                Query::distanceLessThan('name', [0.0, 0.0], 1000),
+            ]);
+            $this->fail('Expected QueryException');
+        } catch (\Exception $e) {
+            $this->assertInstanceOf(QueryException::class, $e);
+            $msg = strtolower($e->getMessage());
+            $this->assertStringContainsString('spatial', $msg);
+        }
+    }
+
+    public function testSpatialIndexSingleAttributeOnly(): void
+    {
+        $locAttr = new Document([
+            '$id' => 'loc', 'key' => 'loc', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Point->value],
+        ]);
+        $loc2Attr = new Document([
+            '$id' => 'loc2', 'key' => 'loc2', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Point->value],
+        ]);
+        $titleAttr = new Document([
+            '$id' => 'title', 'key' => 'title', 'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('spatial_idx_single', [$locAttr, $loc2Attr, $titleAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createIndex('spatial_idx_single', Index::spatial(key: 'idx_multi', attributes: ['loc', 'loc2']));
+            $this->fail('Expected exception for spatial index on multiple attributes');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(IndexException::class, $e);
+        }
+    }
+
+    public function testSpatialIndexOnNonSpatial(): void
+    {
+        $locAttr = new Document([
+            '$id' => 'loc', 'key' => 'loc', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Point->value],
+        ]);
+        $nameAttr = new Document([
+            '$id' => 'name', 'key' => 'name', 'type' => ColumnType::String->value,
+            'size' => 4, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->makeCollection('spatial_nonspatial', [$locAttr, $nameAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createIndex('spatial_nonspatial', Index::spatial(key: 'idx_name_spatial', attributes: ['name']));
+            $this->fail('Expected exception for spatial index on non-spatial attribute');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(IndexException::class, $e);
+        }
+
+        try {
+            $this->database->createIndex('spatial_nonspatial', Index::key(key: 'idx_loc_key', attributes: ['loc']));
+            $this->fail('Expected exception for non-spatial index on spatial attribute');
+        } catch (\Throwable $e) {
+            $this->assertInstanceOf(IndexException::class, $e);
+        }
+    }
+
+    public function testInvalidCoordinateDocuments(): void
+    {
+        $pointAttr = new Document([
+            '$id' => 'pointAttr', 'key' => 'pointAttr', 'type' => ColumnType::Point->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [ColumnType::Point->value],
+        ]);
+
+        $col = $this->makeCollection('test_invalid_coord', [$pointAttr]);
+        $this->setupCollections([$col]);
+
+        $this->expectException(StructureException::class);
+
+        $this->database->createDocument('test_invalid_coord', new Document([
+            '$id' => 'invalidDoc1',
+            '$permissions' => [Permission::read(Role::any())],
+            'pointAttr' => [200.0, 20.0],
+        ]));
+    }
+}
diff --git a/tests/unit/StorageTest.php b/tests/unit/StorageTest.php
new file mode 100644
index 0000000000..4bd829560a
--- /dev/null
+++ b/tests/unit/StorageTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Storage;
+
+final class StorageTest extends TestCase
+{
+    public function test_column_mapping(): void
+    {
+        $this->assertSame(Storage::UID, Storage::column(Document::ID));
+        $this->assertSame(Storage::SEQUENCE, Storage::column(Document::SEQUENCE));
+        $this->assertSame(Document::INTERNAL_ID, Storage::column(Document::INTERNAL_ID));
+        $this->assertSame('title', Storage::column('title'));
+        $this->assertFalse(\defined(Storage::class.'::ID'));
+    }
+
+    public function test_maps_invert(): void
+    {
+        foreach (Storage::attributeMap() as $attribute => $column) {
+            $this->assertSame($attribute, Storage::attribute($column));
+        }
+    }
+
+    public function test_permissions_table(): void
+    {
+        $this->assertSame('movies_perms', Storage::permissionsTable('movies'));
+    }
+}
diff --git a/tests/unit/TenantIdentityTest.php b/tests/unit/TenantIdentityTest.php
new file mode 100644
index 0000000000..f176d96766
--- /dev/null
+++ b/tests/unit/TenantIdentityTest.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace Tests\Unit;
+
+use PDO;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+
+/**
+ * `_tenant` is declared `INT(11) UNSIGNED`, so the engine reads "001" and "1"
+ * as the same tenant and a query for tenant 1 returns rows written under
+ * either. The PHP side has to agree with that: a scope comparison or a cache
+ * key that told the two apart would claim a distinction the rows do not have,
+ * and hand one tenant's cached row to a lookup the engine would have answered
+ * with both.
+ */
+class TenantIdentityTest extends TestCase
+{
+    private function database(int|string|null $tenant): Database
+    {
+        $adapter = new MariaDB($this->createStub(PDO::class));
+        $adapter->setDatabase('test');
+        $adapter->setNamespace('test');
+        $adapter->setSharedTables(true);
+        $adapter->setTenant($tenant);
+
+        return new Database($adapter, new Cache(new None()));
+    }
+
+    private function hashKey(int|string|null $tenant): string
+    {
+        [, , $hashKey] = $this->database($tenant)->getCacheKeys('col', 'doc1');
+
+        return $hashKey;
+    }
+
+    public function testTheCacheKeyFollowsTheTenantTheColumnWillHold(): void
+    {
+        $this->assertSame(
+            $this->hashKey(1),
+            $this->hashKey('001'),
+            'The engine stores "001" as 1 and returns those rows for tenant 1, so the cache key must not separate them',
+        );
+    }
+
+    public function testAStringifiedTenantIsTheSameTenantAsItsInteger(): void
+    {
+        $this->assertSame($this->hashKey(1), $this->hashKey('1'));
+
+        $adapter = new MariaDB($this->createStub(PDO::class));
+        $adapter->setTenant('1');
+
+        $this->assertSame(1, $adapter->getTenant(), 'A driver that stringifies the column must still compare equal to the integer tenant');
+    }
+
+    public function testADocumentTenantNormalisesTheSameWayTheAdapterDoes(): void
+    {
+        $this->assertSame(1, (new Document(['$tenant' => '1']))->getTenant());
+        $this->assertSame(1, (new Document(['$tenant' => '001']))->getTenant());
+    }
+
+    public function testANonNumericTenantIsLeftAlone(): void
+    {
+        $adapter = new MariaDB($this->createStub(PDO::class));
+        $adapter->setTenant('tenant-a');
+
+        $this->assertSame('tenant-a', $adapter->getTenant());
+    }
+}
diff --git a/tests/unit/TransactionRetryTest.php b/tests/unit/TransactionRetryTest.php
index 77fdf73d68..285a6e44d8 100644
--- a/tests/unit/TransactionRetryTest.php
+++ b/tests/unit/TransactionRetryTest.php
@@ -29,19 +29,15 @@ protected function setUp(): void
     public function testTimeoutIsNotRetried(): void
     {
         $attempts = 0;
-        $thrown = null;
 
         try {
             $this->adapter->withTransaction(function () use (&$attempts) {
                 $attempts++;
                 throw new TimeoutException('Query timed out');
             });
-        } catch (TimeoutException $e) {
-            $thrown = $e;
+        } catch (TimeoutException) {
+            $this->assertSame(1, $attempts);
         }
-
-        $this->assertInstanceOf(TimeoutException::class, $thrown);
-        $this->assertSame(1, $attempts);
     }
 
     /**
@@ -51,19 +47,15 @@ public function testTimeoutIsNotRetried(): void
     public function testDuplicateIsNotRetried(): void
     {
         $attempts = 0;
-        $thrown = null;
 
         try {
             $this->adapter->withTransaction(function () use (&$attempts) {
                 $attempts++;
                 throw new DuplicateException('Duplicate');
             });
-        } catch (DuplicateException $e) {
-            $thrown = $e;
+        } catch (DuplicateException) {
+            $this->assertSame(1, $attempts);
         }
-
-        $this->assertInstanceOf(DuplicateException::class, $thrown);
-        $this->assertSame(1, $attempts);
     }
 
     /**
@@ -73,19 +65,15 @@ public function testDuplicateIsNotRetried(): void
     public function testGenericFailureIsRetried(): void
     {
         $attempts = 0;
-        $thrown = null;
 
         try {
             $this->adapter->withTransaction(function () use (&$attempts) {
                 $attempts++;
                 throw new \RuntimeException('transient');
             });
-        } catch (\RuntimeException $e) {
-            $thrown = $e;
+        } catch (\RuntimeException) {
+            $this->assertSame(3, $attempts);
         }
-
-        $this->assertInstanceOf(\RuntimeException::class, $thrown);
-        $this->assertSame(3, $attempts);
     }
 
     /**
@@ -151,11 +139,9 @@ protected function rollbackJournal(): void
         $this->assertInstanceOf(\RuntimeException::class, $thrown);
 
         $inTransaction = new \ReflectionProperty(RedisAdapter::class, 'inTransaction');
-        $inTransaction->setAccessible(true);
         $this->assertSame(0, $inTransaction->getValue($adapter));
 
         $journalStack = new \ReflectionProperty(RedisAdapter::class, 'journalStack');
-        $journalStack->setAccessible(true);
         $this->assertSame([], $journalStack->getValue($adapter));
     }
 }
diff --git a/tests/unit/Type/TypeRegistryTest.php b/tests/unit/Type/TypeRegistryTest.php
new file mode 100644
index 0000000000..ac71615d6e
--- /dev/null
+++ b/tests/unit/Type/TypeRegistryTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Unit\Type;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Type\Custom;
+use Utopia\Database\Type\TypeRegistry;
+use Utopia\Query\Schema\ColumnType;
+
+class TypeRegistryTest extends TestCase
+{
+    public function testRegisterAndGet(): void
+    {
+        $registry = new TypeRegistry();
+        $type = new class () implements Custom {
+            public function name(): string
+            {
+                return 'money';
+            }
+
+            public function columnType(): ColumnType
+            {
+                return ColumnType::Integer;
+            }
+
+            public function columnSize(): int
+            {
+                return 0;
+            }
+
+            public function encode(mixed $value): mixed
+            {
+                if (! \is_int($value) && ! \is_float($value)) {
+                    return 0;
+                }
+
+                return (int) ($value * 100);
+            }
+
+            public function decode(mixed $value): mixed
+            {
+                if (! \is_int($value) && ! \is_float($value)) {
+                    return 0;
+                }
+
+                return $value / 100;
+            }
+        };
+
+        $registry->register($type);
+
+        $this->assertSame($type, $registry->get('money'));
+        $this->assertNull($registry->get('nonexistent'));
+    }
+
+    public function testAll(): void
+    {
+        $registry = new TypeRegistry();
+        $type = new class () implements Custom {
+            public function name(): string
+            {
+                return 'test_type';
+            }
+
+            public function columnType(): ColumnType
+            {
+                return ColumnType::String;
+            }
+
+            public function columnSize(): int
+            {
+                return 255;
+            }
+
+            public function encode(mixed $value): mixed
+            {
+                return $value;
+            }
+
+            public function decode(mixed $value): mixed
+            {
+                return $value;
+            }
+        };
+
+        $registry->register($type);
+        $all = $registry->all();
+
+        $this->assertCount(1, $all);
+        $this->assertArrayHasKey('test_type', $all);
+    }
+}
diff --git a/tests/unit/UniqueViolationTest.php b/tests/unit/UniqueViolationTest.php
index 8d7c8950c1..10b0b52d7c 100644
--- a/tests/unit/UniqueViolationTest.php
+++ b/tests/unit/UniqueViolationTest.php
@@ -179,6 +179,11 @@ private function process(string $adapter, Throwable $exception): Throwable
         $class = new ReflectionClass($adapter);
         $method = $class->getMethod('processException');
 
-        return $method->invoke($class->newInstanceWithoutConstructor(), $exception);
+        $processed = $method->invoke($class->newInstanceWithoutConstructor(), $exception);
+        if (! $processed instanceof Throwable) {
+            throw new \LogicException('Adapter exception processor did not return a throwable');
+        }
+
+        return $processed;
     }
 }
diff --git a/tests/unit/Validator/AttributeTest.php b/tests/unit/Validator/AttributeTest.php
index 65a01c3a75..3e5c9a8ba2 100644
--- a/tests/unit/Validator/AttributeTest.php
+++ b/tests/unit/Validator/AttributeTest.php
@@ -3,31 +3,131 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
 use Utopia\Database\Exception\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Limit as LimitException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Validator\Attribute;
+use Utopia\Database\Validator\Structure;
+use Utopia\Query\Schema\ColumnType;
 
 class AttributeTest extends TestCase
 {
-    public function testDuplicateAttributeId(): void
+    public function testLegacyBigIntegerMetadataNormalizesToCanonicalType(): void
+    {
+        $attribute = AttributeVO::fromDocument(new Document([
+            '$id' => 'total',
+            'type' => AttributeVO::LEGACY_BIG_INTEGER,
+            'size' => 8,
+        ]));
+
+        $this->assertSame(ColumnType::BigInteger, $attribute->type);
+        $this->assertSame(0, $attribute->size);
+        $this->assertSame(ColumnType::BigInteger->value, $attribute->toDocument()->getAttribute('type'));
+
+        $arrayAttribute = AttributeVO::fromArray([
+            '$id' => 'arrayTotal',
+            'type' => AttributeVO::LEGACY_BIG_INTEGER,
+            'size' => 64,
+        ]);
+
+        $this->assertSame(ColumnType::BigInteger, $arrayAttribute->type);
+        $this->assertSame(0, $arrayAttribute->size);
+    }
+
+    public function testBigIntegerDefaultsSupportNativeAndStringBoundaries(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxIntLength: 100,
+            maxBigIntLength: 100,
+            supportUnsignedBigInt: true,
+        );
+
+        $this->assertTrue($validator->isValid(new AttributeVO(
+            key: 'signed',
+            type: ColumnType::BigInteger,
+            size: PHP_INT_MAX,
+            default: PHP_INT_MAX,
+        )));
+        $this->assertTrue($validator->isValid(new AttributeVO(
+            key: 'signedMinimum',
+            type: ColumnType::BigInteger,
+            default: '-9223372036854775808',
+        )));
+        $this->assertTrue($validator->isValid(new AttributeVO(
+            key: 'unsigned',
+            type: ColumnType::BigInteger,
+            default: '18446744073709551615',
+            signed: false,
+        )));
+        $this->assertTrue($validator->isValid(new AttributeVO(
+            key: 'values',
+            type: ColumnType::BigInteger,
+            default: ['-9223372036854775808', PHP_INT_MAX],
+            array: true,
+        )));
+    }
+
+    public function testBigIntegerDefaultRejectsValuesOutsideSignedRange(): void
+    {
+        $validator = new Attribute(attributes: []);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('does not match given type biginteger');
+        $validator->isValid(new AttributeVO(
+            key: 'total',
+            type: ColumnType::BigInteger,
+            default: '9223372036854775808',
+        ));
+    }
+
+    public function testBigIntegerArrayDefaultValidatesEveryValue(): void
+    {
+        $validator = new Attribute(attributes: [], supportUnsignedBigInt: true);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('does not match given type biginteger');
+        $validator->isValid(new AttributeVO(
+            key: 'totals',
+            type: ColumnType::BigInteger,
+            default: ['1', '18446744073709551616'],
+            signed: false,
+            array: true,
+        ));
+    }
+
+    public function testBigSerialUsesBigIntegerValidation(): void
+    {
+        $validator = new Attribute(attributes: []);
+        $attribute = new AttributeVO(
+            key: 'sequence',
+            type: ColumnType::BigSerial,
+            size: 999,
+            default: PHP_INT_MAX,
+        );
+
+        $this->assertTrue($validator->isValid($attribute));
+        $this->assertSame(0, $attribute->size);
+    }
+
+    public function test_duplicate_attribute_id(): void
     {
         $validator = new Attribute(
             attributes: [
                 new Document([
                     '$id' => ID::custom('title'),
                     'key' => 'title',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'size' => 255,
                     'required' => false,
                     'default' => null,
                     'signed' => true,
                     'array' => false,
                     'filters' => [],
-                ])
+                ]),
             ],
             maxStringLength: 16777216,
             maxVarcharLength: 65535,
@@ -37,7 +137,7 @@ public function testDuplicateAttributeId(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -51,7 +151,7 @@ public function testDuplicateAttributeId(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidStringAttribute(): void
+    public function test_valid_string_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -63,7 +163,7 @@ public function testValidStringAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -75,7 +175,7 @@ public function testValidStringAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testStringSizeTooLarge(): void
+    public function test_string_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -87,7 +187,7 @@ public function testStringSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 2000,
             'required' => false,
             'default' => null,
@@ -101,7 +201,7 @@ public function testStringSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testVarcharSizeTooLarge(): void
+    public function test_varchar_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -113,7 +213,7 @@ public function testVarcharSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_VARCHAR,
+            'type' => ColumnType::Varchar->value,
             'size' => 2000,
             'required' => false,
             'default' => null,
@@ -127,7 +227,7 @@ public function testVarcharSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testTextSizeTooLarge(): void
+    public function test_text_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -139,7 +239,7 @@ public function testTextSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_TEXT,
+            'type' => ColumnType::Text->value,
             'size' => 70000,
             'required' => false,
             'default' => null,
@@ -153,7 +253,7 @@ public function testTextSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testMediumtextSizeTooLarge(): void
+    public function test_mediumtext_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -165,7 +265,7 @@ public function testMediumtextSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_MEDIUMTEXT,
+            'type' => ColumnType::MediumText->value,
             'size' => 20000000,
             'required' => false,
             'default' => null,
@@ -179,7 +279,7 @@ public function testMediumtextSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testIntegerSizeTooLarge(): void
+    public function test_integer_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -191,7 +291,7 @@ public function testIntegerSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 200,
             'required' => false,
             'default' => null,
@@ -205,7 +305,7 @@ public function testIntegerSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testUnknownType(): void
+    public function test_unknown_type(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -231,7 +331,7 @@ public function testUnknownType(): void
         $validator->isValid($attribute);
     }
 
-    public function testRequiredFiltersForDatetime(): void
+    public function test_required_filters_for_datetime(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -243,7 +343,7 @@ public function testRequiredFiltersForDatetime(): void
         $attribute = new Document([
             '$id' => ID::custom('created'),
             'key' => 'created',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -257,7 +357,7 @@ public function testRequiredFiltersForDatetime(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidDatetimeWithFilter(): void
+    public function test_valid_datetime_with_filter(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -269,7 +369,7 @@ public function testValidDatetimeWithFilter(): void
         $attribute = new Document([
             '$id' => ID::custom('created'),
             'key' => 'created',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -281,7 +381,7 @@ public function testValidDatetimeWithFilter(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testDefaultValueOnRequiredAttribute(): void
+    public function test_default_value_on_required_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -293,7 +393,7 @@ public function testDefaultValueOnRequiredAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => true,
             'default' => 'default value',
@@ -307,7 +407,7 @@ public function testDefaultValueOnRequiredAttribute(): void
         $validator->isValid($attribute);
     }
 
-    public function testDefaultValueTypeMismatch(): void
+    public function test_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -319,7 +419,7 @@ public function testDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 4,
             'required' => false,
             'default' => 'not_an_integer',
@@ -329,11 +429,11 @@ public function testDefaultValueTypeMismatch(): void
         ]);
 
         $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Default value not_an_integer does not match given type integer');
+        $this->expectExceptionMessage('Default value "not_an_integer" does not match given type integer');
         $validator->isValid($attribute);
     }
 
-    public function testVectorNotSupported(): void
+    public function test_vector_not_supported(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -346,7 +446,7 @@ public function testVectorNotSupported(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 128,
             'required' => false,
             'default' => null,
@@ -360,7 +460,7 @@ public function testVectorNotSupported(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorCannotBeArray(): void
+    public function test_vector_cannot_be_array(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -373,7 +473,7 @@ public function testVectorCannotBeArray(): void
         $attribute = new Document([
             '$id' => ID::custom('embeddings'),
             'key' => 'embeddings',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 128,
             'required' => false,
             'default' => null,
@@ -387,7 +487,7 @@ public function testVectorCannotBeArray(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorInvalidDimensions(): void
+    public function test_vector_invalid_dimensions(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -400,7 +500,7 @@ public function testVectorInvalidDimensions(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -414,7 +514,7 @@ public function testVectorInvalidDimensions(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorDimensionsExceedsMax(): void
+    public function test_vector_dimensions_exceeds_max(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -427,7 +527,7 @@ public function testVectorDimensionsExceedsMax(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 20000,
             'required' => false,
             'default' => null,
@@ -441,7 +541,7 @@ public function testVectorDimensionsExceedsMax(): void
         $validator->isValid($attribute);
     }
 
-    public function testSpatialNotSupported(): void
+    public function test_spatial_not_supported(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -454,7 +554,7 @@ public function testSpatialNotSupported(): void
         $attribute = new Document([
             '$id' => ID::custom('location'),
             'key' => 'location',
-            'type' => Database::VAR_POINT,
+            'type' => ColumnType::Point->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -468,7 +568,7 @@ public function testSpatialNotSupported(): void
         $validator->isValid($attribute);
     }
 
-    public function testSpatialCannotBeArray(): void
+    public function test_spatial_cannot_be_array(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -481,7 +581,7 @@ public function testSpatialCannotBeArray(): void
         $attribute = new Document([
             '$id' => ID::custom('locations'),
             'key' => 'locations',
-            'type' => Database::VAR_POINT,
+            'type' => ColumnType::Point->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -495,7 +595,7 @@ public function testSpatialCannotBeArray(): void
         $validator->isValid($attribute);
     }
 
-    public function testSpatialMustHaveEmptySize(): void
+    public function test_spatial_must_have_empty_size(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -508,7 +608,7 @@ public function testSpatialMustHaveEmptySize(): void
         $attribute = new Document([
             '$id' => ID::custom('location'),
             'key' => 'location',
-            'type' => Database::VAR_POINT,
+            'type' => ColumnType::Point->value,
             'size' => 100,
             'required' => false,
             'default' => null,
@@ -522,7 +622,7 @@ public function testSpatialMustHaveEmptySize(): void
         $validator->isValid($attribute);
     }
 
-    public function testObjectNotSupported(): void
+    public function test_object_not_supported(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -535,7 +635,7 @@ public function testObjectNotSupported(): void
         $attribute = new Document([
             '$id' => ID::custom('metadata'),
             'key' => 'metadata',
-            'type' => Database::VAR_OBJECT,
+            'type' => ColumnType::Object->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -549,7 +649,7 @@ public function testObjectNotSupported(): void
         $validator->isValid($attribute);
     }
 
-    public function testObjectCannotBeArray(): void
+    public function test_object_cannot_be_array(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -562,7 +662,7 @@ public function testObjectCannotBeArray(): void
         $attribute = new Document([
             '$id' => ID::custom('metadata'),
             'key' => 'metadata',
-            'type' => Database::VAR_OBJECT,
+            'type' => ColumnType::Object->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -576,7 +676,7 @@ public function testObjectCannotBeArray(): void
         $validator->isValid($attribute);
     }
 
-    public function testObjectMustHaveEmptySize(): void
+    public function test_object_must_have_empty_size(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -589,7 +689,7 @@ public function testObjectMustHaveEmptySize(): void
         $attribute = new Document([
             '$id' => ID::custom('metadata'),
             'key' => 'metadata',
-            'type' => Database::VAR_OBJECT,
+            'type' => ColumnType::Object->value,
             'size' => 100,
             'required' => false,
             'default' => null,
@@ -603,7 +703,7 @@ public function testObjectMustHaveEmptySize(): void
         $validator->isValid($attribute);
     }
 
-    public function testAttributeLimitExceeded(): void
+    public function test_attribute_limit_exceeded(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -619,7 +719,7 @@ public function testAttributeLimitExceeded(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -633,7 +733,7 @@ public function testAttributeLimitExceeded(): void
         $validator->isValid($attribute);
     }
 
-    public function testRowWidthLimitExceeded(): void
+    public function test_row_width_limit_exceeded(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -649,7 +749,7 @@ public function testRowWidthLimitExceeded(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -663,7 +763,7 @@ public function testRowWidthLimitExceeded(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorDefaultValueNotArray(): void
+    public function test_vector_default_value_not_array(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -676,7 +776,7 @@ public function testVectorDefaultValueNotArray(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 3,
             'required' => false,
             'default' => 'not_an_array',
@@ -690,7 +790,7 @@ public function testVectorDefaultValueNotArray(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorDefaultValueWrongElementCount(): void
+    public function test_vector_default_value_wrong_element_count(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -703,7 +803,7 @@ public function testVectorDefaultValueWrongElementCount(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 3,
             'required' => false,
             'default' => [1.0, 2.0],
@@ -717,7 +817,7 @@ public function testVectorDefaultValueWrongElementCount(): void
         $validator->isValid($attribute);
     }
 
-    public function testVectorDefaultValueNonNumericElements(): void
+    public function test_vector_default_value_non_numeric_elements(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -730,7 +830,7 @@ public function testVectorDefaultValueNonNumericElements(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 3,
             'required' => false,
             'default' => [1.0, 'not_a_number', 3.0],
@@ -744,7 +844,7 @@ public function testVectorDefaultValueNonNumericElements(): void
         $validator->isValid($attribute);
     }
 
-    public function testLongtextSizeTooLarge(): void
+    public function test_longtext_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -756,7 +856,7 @@ public function testLongtextSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_LONGTEXT,
+            'type' => ColumnType::LongText->value,
             'size' => 5000000000,
             'required' => false,
             'default' => null,
@@ -770,7 +870,7 @@ public function testLongtextSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidVarcharAttribute(): void
+    public function test_valid_varchar_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -782,7 +882,7 @@ public function testValidVarcharAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('name'),
             'key' => 'name',
-            'type' => Database::VAR_VARCHAR,
+            'type' => ColumnType::Varchar->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -794,7 +894,7 @@ public function testValidVarcharAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidTextAttribute(): void
+    public function test_valid_text_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -806,7 +906,7 @@ public function testValidTextAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_TEXT,
+            'type' => ColumnType::Text->value,
             'size' => 65535,
             'required' => false,
             'default' => null,
@@ -818,7 +918,7 @@ public function testValidTextAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidMediumtextAttribute(): void
+    public function test_valid_mediumtext_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -830,7 +930,7 @@ public function testValidMediumtextAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_MEDIUMTEXT,
+            'type' => ColumnType::MediumText->value,
             'size' => 16777215,
             'required' => false,
             'default' => null,
@@ -842,7 +942,7 @@ public function testValidMediumtextAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidLongtextAttribute(): void
+    public function test_valid_longtext_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -854,7 +954,7 @@ public function testValidLongtextAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_LONGTEXT,
+            'type' => ColumnType::LongText->value,
             'size' => 4294967295,
             'required' => false,
             'default' => null,
@@ -866,7 +966,7 @@ public function testValidLongtextAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidFloatAttribute(): void
+    public function test_valid_float_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -878,7 +978,7 @@ public function testValidFloatAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('price'),
             'key' => 'price',
-            'type' => Database::VAR_FLOAT,
+            'type' => ColumnType::Double->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -890,7 +990,7 @@ public function testValidFloatAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidBooleanAttribute(): void
+    public function test_valid_boolean_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -902,7 +1002,7 @@ public function testValidBooleanAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('active'),
             'key' => 'active',
-            'type' => Database::VAR_BOOLEAN,
+            'type' => ColumnType::Boolean->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -914,7 +1014,7 @@ public function testValidBooleanAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testFloatDefaultValueTypeMismatch(): void
+    public function test_float_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -926,7 +1026,7 @@ public function testFloatDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('price'),
             'key' => 'price',
-            'type' => Database::VAR_FLOAT,
+            'type' => ColumnType::Double->value,
             'size' => 0,
             'required' => false,
             'default' => 'not_a_float',
@@ -936,11 +1036,11 @@ public function testFloatDefaultValueTypeMismatch(): void
         ]);
 
         $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Default value not_a_float does not match given type double');
+        $this->expectExceptionMessage('Default value "not_a_float" does not match given type double');
         $validator->isValid($attribute);
     }
 
-    public function testBooleanDefaultValueTypeMismatch(): void
+    public function test_boolean_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -952,7 +1052,7 @@ public function testBooleanDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('active'),
             'key' => 'active',
-            'type' => Database::VAR_BOOLEAN,
+            'type' => ColumnType::Boolean->value,
             'size' => 0,
             'required' => false,
             'default' => 'not_a_boolean',
@@ -962,11 +1062,11 @@ public function testBooleanDefaultValueTypeMismatch(): void
         ]);
 
         $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Default value not_a_boolean does not match given type boolean');
+        $this->expectExceptionMessage('Default value "not_a_boolean" does not match given type boolean');
         $validator->isValid($attribute);
     }
 
-    public function testStringDefaultValueTypeMismatch(): void
+    public function test_string_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -978,7 +1078,7 @@ public function testStringDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => 123,
@@ -992,7 +1092,7 @@ public function testStringDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidStringWithDefaultValue(): void
+    public function test_valid_string_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1004,7 +1104,7 @@ public function testValidStringWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => 'default title',
@@ -1016,7 +1116,7 @@ public function testValidStringWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidIntegerWithDefaultValue(): void
+    public function test_valid_integer_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1028,7 +1128,7 @@ public function testValidIntegerWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 4,
             'required' => false,
             'default' => 42,
@@ -1040,57 +1140,7 @@ public function testValidIntegerWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testInvalidBigIntDefaultValueTypeStringNotNumeric(): void
-    {
-        $validator = new Attribute(
-            attributes: [],
-            maxStringLength: 16777216,
-            maxVarcharLength: 65535,
-            maxIntLength: PHP_INT_MAX,
-        );
-
-        $attribute = new Document([
-            '$id' => ID::custom('counter'),
-            'key' => 'counter',
-            'type' => Database::VAR_BIGINT,
-            'size' => 0,
-            'required' => false,
-            'default' => 'not_a_bigint',
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $this->expectException(DatabaseException::class);
-        $this->expectExceptionMessage('Default value not_a_bigint is not a valid integer string for type bigint');
-        $validator->isValid($attribute);
-    }
-
-    public function testValidBigIntDefaultValueTypeStringNumeric(): void
-    {
-        $validator = new Attribute(
-            attributes: [],
-            maxStringLength: 16777216,
-            maxVarcharLength: 65535,
-            maxIntLength: PHP_INT_MAX,
-        );
-
-        $attribute = new Document([
-            '$id' => ID::custom('counter'),
-            'key' => 'counter',
-            'type' => Database::VAR_BIGINT,
-            'size' => 0,
-            'required' => false,
-            'default' => '123',
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $this->assertTrue($validator->isValid($attribute));
-    }
-
-    public function testValidFloatWithDefaultValue(): void
+    public function test_valid_float_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1102,7 +1152,7 @@ public function testValidFloatWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('price'),
             'key' => 'price',
-            'type' => Database::VAR_FLOAT,
+            'type' => ColumnType::Double->value,
             'size' => 0,
             'required' => false,
             'default' => 19.99,
@@ -1114,7 +1164,7 @@ public function testValidFloatWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidBooleanWithDefaultValue(): void
+    public function test_valid_boolean_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1126,7 +1176,7 @@ public function testValidBooleanWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('active'),
             'key' => 'active',
-            'type' => Database::VAR_BOOLEAN,
+            'type' => ColumnType::Boolean->value,
             'size' => 0,
             'required' => false,
             'default' => true,
@@ -1138,7 +1188,7 @@ public function testValidBooleanWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testUnsignedIntegerSizeLimit(): void
+    public function test_unsigned_integer_size_limit(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1151,7 +1201,7 @@ public function testUnsignedIntegerSizeLimit(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 80,
             'required' => false,
             'default' => null,
@@ -1163,7 +1213,7 @@ public function testUnsignedIntegerSizeLimit(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testUnsignedIntegerSizeTooLarge(): void
+    public function test_unsigned_integer_size_too_large(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1175,7 +1225,7 @@ public function testUnsignedIntegerSizeTooLarge(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 150,
             'required' => false,
             'default' => null,
@@ -1189,71 +1239,21 @@ public function testUnsignedIntegerSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testBigIntSizeNotLimited(): void
-    {
-        $validator = new Attribute(
-            attributes: [],
-            maxStringLength: 16777216,
-            maxVarcharLength: 65535,
-            maxIntLength: PHP_INT_MAX,
-            maxBigIntLength: 200,
-        );
-
-        $attribute = new Document([
-            '$id' => ID::custom('counter'),
-            'key' => 'counter',
-            'type' => Database::VAR_BIGINT,
-            'size' => 101,
-            'required' => false,
-            'default' => null,
-            'signed' => true,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $this->assertTrue($validator->isValid($attribute));
-    }
-
-    public function testUnsignedBigIntSizeLimit(): void
-    {
-        $validator = new Attribute(
-            attributes: [],
-            maxStringLength: 16777216,
-            maxVarcharLength: 65535,
-            maxIntLength: PHP_INT_MAX,
-            maxBigIntLength: 200,
-        );
-
-        $attribute = new Document([
-            '$id' => ID::custom('counter'),
-            'key' => 'counter',
-            'type' => Database::VAR_BIGINT,
-            'size' => 200,
-            'required' => false,
-            'default' => null,
-            'signed' => false,
-            'array' => false,
-            'filters' => [],
-        ]);
-
-        $this->assertTrue($validator->isValid($attribute));
-    }
-
-    public function testDuplicateAttributeIdCaseInsensitive(): void
+    public function test_duplicate_attribute_id_case_insensitive(): void
     {
         $validator = new Attribute(
             attributes: [
                 new Document([
                     '$id' => ID::custom('Title'),
                     'key' => 'Title',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'size' => 255,
                     'required' => false,
                     'default' => null,
                     'signed' => true,
                     'array' => false,
                     'filters' => [],
-                ])
+                ]),
             ],
             maxStringLength: 16777216,
             maxVarcharLength: 65535,
@@ -1263,7 +1263,7 @@ public function testDuplicateAttributeIdCaseInsensitive(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -1277,7 +1277,7 @@ public function testDuplicateAttributeIdCaseInsensitive(): void
         $validator->isValid($attribute);
     }
 
-    public function testDuplicateInSchema(): void
+    public function test_duplicate_in_schema(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1285,9 +1285,9 @@ public function testDuplicateInSchema(): void
                 new Document([
                     '$id' => ID::custom('existing_column'),
                     'key' => 'existing_column',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'size' => 255,
-                ])
+                ]),
             ],
             maxStringLength: 16777216,
             maxVarcharLength: 65535,
@@ -1298,7 +1298,7 @@ public function testDuplicateInSchema(): void
         $attribute = new Document([
             '$id' => ID::custom('existing_column'),
             'key' => 'existing_column',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -1312,7 +1312,7 @@ public function testDuplicateInSchema(): void
         $validator->isValid($attribute);
     }
 
-    public function testSchemaCheckSkippedWhenMigrating(): void
+    public function test_schema_check_skipped_when_migrating(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1320,9 +1320,9 @@ public function testSchemaCheckSkippedWhenMigrating(): void
                 new Document([
                     '$id' => ID::custom('existing_column'),
                     'key' => 'existing_column',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'size' => 255,
-                ])
+                ]),
             ],
             maxStringLength: 16777216,
             maxVarcharLength: 65535,
@@ -1335,7 +1335,7 @@ public function testSchemaCheckSkippedWhenMigrating(): void
         $attribute = new Document([
             '$id' => ID::custom('existing_column'),
             'key' => 'existing_column',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -1347,7 +1347,7 @@ public function testSchemaCheckSkippedWhenMigrating(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidLinestringAttribute(): void
+    public function test_valid_linestring_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1360,7 +1360,7 @@ public function testValidLinestringAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('route'),
             'key' => 'route',
-            'type' => Database::VAR_LINESTRING,
+            'type' => ColumnType::Linestring->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -1372,7 +1372,7 @@ public function testValidLinestringAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidPolygonAttribute(): void
+    public function test_valid_polygon_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1385,7 +1385,7 @@ public function testValidPolygonAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('area'),
             'key' => 'area',
-            'type' => Database::VAR_POLYGON,
+            'type' => ColumnType::Polygon->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -1397,7 +1397,7 @@ public function testValidPolygonAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidPointAttribute(): void
+    public function test_valid_point_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1410,7 +1410,7 @@ public function testValidPointAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('location'),
             'key' => 'location',
-            'type' => Database::VAR_POINT,
+            'type' => ColumnType::Point->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -1422,7 +1422,7 @@ public function testValidPointAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidVectorAttribute(): void
+    public function test_valid_vector_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1435,7 +1435,7 @@ public function testValidVectorAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 128,
             'required' => false,
             'default' => null,
@@ -1447,7 +1447,7 @@ public function testValidVectorAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidVectorWithDefaultValue(): void
+    public function test_valid_vector_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1460,7 +1460,7 @@ public function testValidVectorWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('embedding'),
             'key' => 'embedding',
-            'type' => Database::VAR_VECTOR,
+            'type' => ColumnType::Vector->value,
             'size' => 3,
             'required' => false,
             'default' => [1.0, 2.0, 3.0],
@@ -1472,7 +1472,7 @@ public function testValidVectorWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidObjectAttribute(): void
+    public function test_valid_object_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1485,7 +1485,7 @@ public function testValidObjectAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('metadata'),
             'key' => 'metadata',
-            'type' => Database::VAR_OBJECT,
+            'type' => ColumnType::Object->value,
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -1497,7 +1497,7 @@ public function testValidObjectAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testArrayStringAttribute(): void
+    public function test_array_string_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1509,7 +1509,7 @@ public function testArrayStringAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('tags'),
             'key' => 'tags',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -1521,7 +1521,7 @@ public function testArrayStringAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testArrayWithDefaultValues(): void
+    public function test_array_with_default_values(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1533,7 +1533,7 @@ public function testArrayWithDefaultValues(): void
         $attribute = new Document([
             '$id' => ID::custom('tags'),
             'key' => 'tags',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => ['tag1', 'tag2', 'tag3'],
@@ -1545,7 +1545,7 @@ public function testArrayWithDefaultValues(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testArrayDefaultValueTypeMismatch(): void
+    public function test_array_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1557,7 +1557,7 @@ public function testArrayDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('tags'),
             'key' => 'tags',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => ['tag1', 123, 'tag3'],
@@ -1571,7 +1571,7 @@ public function testArrayDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testDatetimeDefaultValueMustBeString(): void
+    public function test_datetime_default_value_must_be_string(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1583,7 +1583,7 @@ public function testDatetimeDefaultValueMustBeString(): void
         $attribute = new Document([
             '$id' => ID::custom('created'),
             'key' => 'created',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'required' => false,
             'default' => 12345,
@@ -1597,7 +1597,7 @@ public function testDatetimeDefaultValueMustBeString(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidDatetimeWithDefaultValue(): void
+    public function test_valid_datetime_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1609,7 +1609,7 @@ public function testValidDatetimeWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('created'),
             'key' => 'created',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'required' => false,
             'default' => '2024-01-01T00:00:00.000Z',
@@ -1621,7 +1621,7 @@ public function testValidDatetimeWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testVarcharDefaultValueTypeMismatch(): void
+    public function test_varchar_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1633,7 +1633,7 @@ public function testVarcharDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('name'),
             'key' => 'name',
-            'type' => Database::VAR_VARCHAR,
+            'type' => ColumnType::Varchar->value,
             'size' => 255,
             'required' => false,
             'default' => 123,
@@ -1647,7 +1647,7 @@ public function testVarcharDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testTextDefaultValueTypeMismatch(): void
+    public function test_text_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1659,7 +1659,7 @@ public function testTextDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_TEXT,
+            'type' => ColumnType::Text->value,
             'size' => 65535,
             'required' => false,
             'default' => 123,
@@ -1673,7 +1673,7 @@ public function testTextDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testMediumtextDefaultValueTypeMismatch(): void
+    public function test_mediumtext_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1685,7 +1685,7 @@ public function testMediumtextDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_MEDIUMTEXT,
+            'type' => ColumnType::MediumText->value,
             'size' => 16777215,
             'required' => false,
             'default' => 123,
@@ -1699,7 +1699,7 @@ public function testMediumtextDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testLongtextDefaultValueTypeMismatch(): void
+    public function test_longtext_default_value_type_mismatch(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1711,7 +1711,7 @@ public function testLongtextDefaultValueTypeMismatch(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_LONGTEXT,
+            'type' => ColumnType::LongText->value,
             'size' => 4294967295,
             'required' => false,
             'default' => 123,
@@ -1725,7 +1725,7 @@ public function testLongtextDefaultValueTypeMismatch(): void
         $validator->isValid($attribute);
     }
 
-    public function testValidVarcharWithDefaultValue(): void
+    public function test_valid_varchar_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1737,7 +1737,7 @@ public function testValidVarcharWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('name'),
             'key' => 'name',
-            'type' => Database::VAR_VARCHAR,
+            'type' => ColumnType::Varchar->value,
             'size' => 255,
             'required' => false,
             'default' => 'default name',
@@ -1749,7 +1749,7 @@ public function testValidVarcharWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidTextWithDefaultValue(): void
+    public function test_valid_text_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1761,7 +1761,7 @@ public function testValidTextWithDefaultValue(): void
         $attribute = new Document([
             '$id' => ID::custom('content'),
             'key' => 'content',
-            'type' => Database::VAR_TEXT,
+            'type' => ColumnType::Text->value,
             'size' => 65535,
             'required' => false,
             'default' => 'default content',
@@ -1773,7 +1773,7 @@ public function testValidTextWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidIntegerAttribute(): void
+    public function test_valid_integer_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1785,7 +1785,7 @@ public function testValidIntegerAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('count'),
             'key' => 'count',
-            'type' => Database::VAR_INTEGER,
+            'type' => ColumnType::Integer->value,
             'size' => 4,
             'required' => false,
             'default' => null,
@@ -1797,7 +1797,7 @@ public function testValidIntegerAttribute(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testNullDefaultValueAllowed(): void
+    public function test_null_default_value_allowed(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1809,7 +1809,7 @@ public function testNullDefaultValueAllowed(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => null,
@@ -1821,7 +1821,7 @@ public function testNullDefaultValueAllowed(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testArrayDefaultOnNonArrayAttribute(): void
+    public function test_array_default_on_non_array_attribute(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1833,7 +1833,7 @@ public function testArrayDefaultOnNonArrayAttribute(): void
         $attribute = new Document([
             '$id' => ID::custom('title'),
             'key' => 'title',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 255,
             'required' => false,
             'default' => ['not', 'allowed'],
@@ -1846,4 +1846,377 @@ public function testArrayDefaultOnNonArrayAttribute(): void
         $this->expectExceptionMessage('Cannot set an array default value for a non-array attribute');
         $validator->isValid($attribute);
     }
+
+    public function test_array_default_allowed_on_json_filter_attribute(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attribute = new Document([
+            '$id' => ID::custom('services'),
+            'key' => 'services',
+            'type' => ColumnType::String->value,
+            'size' => 16384,
+            'required' => false,
+            'default' => [],
+            'signed' => true,
+            'array' => false,
+            'filters' => ['json'],
+        ]);
+
+        $this->assertTrue($validator->isValid($attribute));
+    }
+
+    public function test_object_default_allowed_on_json_filter_attribute(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attribute = new Document([
+            '$id' => ID::custom('data'),
+            'key' => 'data',
+            'type' => ColumnType::String->value,
+            'size' => 65535,
+            'required' => false,
+            'default' => new \stdClass(),
+            'signed' => true,
+            'array' => false,
+            'filters' => ['json', 'encrypt'],
+        ]);
+
+        $this->assertTrue($validator->isValid($attribute));
+    }
+
+    public function test_get_type(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $this->assertEquals('object', $validator->getType());
+    }
+
+    public function test_get_description(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $this->assertEquals('Invalid attribute', $validator->getDescription());
+    }
+
+    public function test_is_array(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $this->assertFalse($validator->isArray());
+    }
+
+    public function test_is_valid_with_attribute_vo_directly(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'directAttr',
+            type: ColumnType::String,
+            size: 255,
+            required: false,
+            default: null,
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->assertTrue($validator->isValid($attrVO));
+    }
+
+    public function test_attribute_does_not_collide_with_schema(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            schemaAttributes: [
+                new Document([
+                    '$id' => ID::custom('existing_column'),
+                    'key' => 'existing_column',
+                    'type' => ColumnType::String->value,
+                    'size' => 255,
+                ]),
+            ],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+            supportForSchemaAttributes: true,
+        );
+
+        $attribute = new Document([
+            '$id' => ID::custom('new_column'),
+            'key' => 'new_column',
+            'type' => ColumnType::String->value,
+            'size' => 255,
+            'required' => false,
+            'default' => null,
+            'signed' => true,
+            'array' => false,
+            'filters' => [],
+        ]);
+
+        $this->assertTrue($validator->isValid($attribute));
+    }
+
+    public function test_invalid_format_for_type(): void
+    {
+        Structure::addFormat('testformat', function (mixed $attribute) {
+            return new \Utopia\Validator\Text(100);
+        }, ColumnType::Integer);
+
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attribute = new Document([
+            '$id' => ID::custom('formatted'),
+            'key' => 'formatted',
+            'type' => ColumnType::String->value,
+            'size' => 255,
+            'required' => false,
+            'default' => null,
+            'signed' => true,
+            'array' => false,
+            'format' => 'testformat',
+            'filters' => [],
+        ]);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Format ("testformat") not available for this attribute type ("string")');
+        $validator->isValid($attribute);
+    }
+
+    public function test_id_type_attribute_validation(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'myId',
+            type: ColumnType::Id,
+            size: 0,
+            required: false,
+            default: null,
+            signed: false,
+            array: false,
+            filters: [],
+        );
+
+        $this->assertTrue($validator->isValid($attrVO));
+    }
+
+    public function test_unknown_column_type_in_check_type(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'badtype',
+            type: ColumnType::Enum,
+            size: 0,
+            required: false,
+            default: null,
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Unknown attribute type: enum');
+        $validator->isValid($attrVO);
+    }
+
+    public function test_null_default_value_in_validate_default_types(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'nullableField',
+            type: ColumnType::String,
+            size: 255,
+            required: false,
+            default: null,
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->assertTrue($validator->isValid($attrVO));
+    }
+
+    public function test_vector_component_non_numeric_default_type(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+            supportForVectors: true,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'vec',
+            type: ColumnType::Vector,
+            size: 3,
+            required: false,
+            default: [1.0, 2.0, 3.0],
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->assertTrue($validator->isValid($attrVO));
+
+        $validator2 = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+            supportForVectors: true,
+        );
+
+        $attrVO2 = new AttributeVO(
+            key: 'vec2',
+            type: ColumnType::Vector,
+            size: 3,
+            required: false,
+            default: [1.0, 'notANumber', 3.0],
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Vector default value must contain only numeric elements');
+        $validator2->isValid($attrVO2);
+    }
+
+    public function test_unknown_column_type_with_default_value(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'baddefault',
+            type: ColumnType::Enum,
+            size: 0,
+            required: false,
+            default: 'somevalue',
+            signed: true,
+            array: false,
+            filters: [],
+        );
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Unknown attribute type: enum');
+        $validator->isValid($attrVO);
+    }
+
+    public function test_schema_duplicate_check_with_filter_callback(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            schemaAttributes: [
+                new Document([
+                    '$id' => ID::custom('_prefix_column'),
+                    'key' => '_prefix_column',
+                    'type' => ColumnType::String->value,
+                    'size' => 255,
+                ]),
+            ],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+            supportForSchemaAttributes: true,
+            filterCallback: fn (string $key) => str_replace('_prefix_', '', $key),
+        );
+
+        $attribute = new Document([
+            '$id' => ID::custom('column'),
+            'key' => 'column',
+            'type' => ColumnType::String->value,
+            'size' => 255,
+            'required' => false,
+            'default' => null,
+            'signed' => true,
+            'array' => false,
+            'filters' => [],
+        ]);
+
+        $this->expectException(DuplicateException::class);
+        $this->expectExceptionMessage('Attribute already exists in schema');
+        $validator->isValid($attribute);
+    }
+
+    public function test_relationship_type_passes_check_type(): void
+    {
+        $validator = new Attribute(
+            attributes: [],
+            maxStringLength: 16777216,
+            maxVarcharLength: 65535,
+            maxIntLength: PHP_INT_MAX,
+        );
+
+        $attrVO = new AttributeVO(
+            key: 'parent',
+            type: ColumnType::Relationship,
+            size: 0,
+            required: false,
+            default: null,
+            signed: false,
+            array: false,
+            filters: [],
+        );
+
+        $this->assertTrue($validator->isValid($attrVO));
+    }
 }
diff --git a/tests/unit/Validator/AuthorizationTest.php b/tests/unit/Validator/AuthorizationTest.php
index e8685549e3..b51763c07e 100644
--- a/tests/unit/Validator/AuthorizationTest.php
+++ b/tests/unit/Validator/AuthorizationTest.php
@@ -3,11 +3,11 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\PermissionType;
 use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\Authorization\Input;
 
@@ -15,16 +15,16 @@ class AuthorizationTest extends TestCase
 {
     protected Authorization $authorization;
 
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->authorization = new Authorization();
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testValues(): void
+    public function test_values(): void
     {
         $this->authorization->addRole(Role::any()->toString());
 
@@ -42,8 +42,8 @@ public function testValues(): void
 
         $object = $this->authorization;
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), false);
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, [])), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, [])), false);
         $this->assertEquals($object->getDescription(), 'No permissions provided for action \'read\'');
 
         $this->authorization->addRole(Role::user('456')->toString());
@@ -54,37 +54,37 @@ public function testValues(): void
         $this->assertEquals($this->authorization->hasRole(''), false);
         $this->assertEquals($this->authorization->hasRole(Role::any()->toString()), true);
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), true);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), true);
 
         $this->authorization->cleanRoles();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), false);
 
         $this->authorization->addRole(Role::team('123')->toString());
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), true);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), true);
 
         $this->authorization->cleanRoles();
         $this->authorization->disable();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), true);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), true);
 
         $this->authorization->reset();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), false);
 
         $this->authorization->setDefaultStatus(false);
         $this->authorization->disable();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), true);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), true);
 
         $this->authorization->reset();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), true);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), true);
 
         $this->authorization->enable();
 
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), false);
 
         $this->authorization->addRole('textX');
 
@@ -95,13 +95,13 @@ public function testValues(): void
         $this->assertNotContains('textX', $this->authorization->getRoles());
 
         // Test skip method
-        $this->assertEquals($object->isValid(new Input(Database::PERMISSION_READ, $document->getRead())), false);
+        $this->assertEquals($object->isValid(new Input(PermissionType::Read, $document->getRead())), false);
         $this->assertEquals($this->authorization->skip(function () use ($object, $document) {
-            return $object->isValid(new Input(Database::PERMISSION_READ, $document->getRead()));
+            return $object->isValid(new Input(PermissionType::Read, $document->getRead()));
         }), true);
     }
 
-    public function testNestedSkips(): void
+    public function test_nested_skips(): void
     {
         $this->assertEquals(true, $this->authorization->getStatus());
 
diff --git a/tests/unit/Validator/DateTimeTest.php b/tests/unit/Validator/DateTimeTest.php
index 106080c298..3a400b441a 100644
--- a/tests/unit/Validator/DateTimeTest.php
+++ b/tests/unit/Validator/DateTimeTest.php
@@ -9,35 +9,32 @@
 class DateTimeTest extends TestCase
 {
     private \DateTime $minAllowed;
+
     private \DateTime $maxAllowed;
+
     private string $minString = '0000-01-01 00:00:00';
+
     private string $maxString = '9999-12-31 23:59:59';
 
-    public function __construct()
+    protected function setUp(): void
     {
-        parent::__construct();
-
         $this->minAllowed = new \DateTime($this->minString);
         $this->maxAllowed = new \DateTime($this->maxString);
     }
 
-    public function setUp(): void
+    protected function tearDown(): void
     {
     }
 
-    public function tearDown(): void
-    {
-    }
-
-    public function testCreateDatetime(): void
+    public function test_create_datetime(): void
     {
         $dateValidator = new DatetimeValidator($this->minAllowed, $this->maxAllowed);
 
         $this->assertGreaterThan(DateTime::addSeconds(new \DateTime(), -3), DateTime::now());
-        $this->assertEquals(true, $dateValidator->isValid("2022-12-04"));
-        $this->assertEquals(true, $dateValidator->isValid("2022-1-4 11:31"));
-        $this->assertEquals(true, $dateValidator->isValid("2022-12-04 11:31:52"));
-        $this->assertEquals(true, $dateValidator->isValid("2022-1-4 11:31:52.123456789"));
+        $this->assertEquals(true, $dateValidator->isValid('2022-12-04'));
+        $this->assertEquals(true, $dateValidator->isValid('2022-1-4 11:31'));
+        $this->assertEquals(true, $dateValidator->isValid('2022-12-04 11:31:52'));
+        $this->assertEquals(true, $dateValidator->isValid('2022-1-4 11:31:52.123456789'));
         $this->assertGreaterThan('2022-7-2', '2022-7-2 11:31:52.680');
         $now = DateTime::now();
         $this->assertEquals(23, strlen($now));
@@ -55,21 +52,21 @@ public function testCreateDatetime(): void
         $this->assertEquals('52', $dateObject->format('s'));
         $this->assertEquals('680', $dateObject->format('v'));
 
-        $this->assertEquals(true, $dateValidator->isValid("2022-12-04 11:31:52.680+02:00"));
+        $this->assertEquals(true, $dateValidator->isValid('2022-12-04 11:31:52.680+02:00'));
         $this->assertEquals('UTC', date_default_timezone_get());
-        $this->assertEquals("2022-12-04 09:31:52.680", DateTime::setTimezone("2022-12-04 11:31:52.680+02:00"));
-        $this->assertEquals("2022-12-04T09:31:52.681+00:00", DateTime::formatTz("2022-12-04 09:31:52.681"));
+        $this->assertEquals('2022-12-04 09:31:52.680', DateTime::setTimezone('2022-12-04 11:31:52.680+02:00'));
+        $this->assertEquals('2022-12-04T09:31:52.681+00:00', DateTime::formatTz('2022-12-04 09:31:52.681'));
 
         /**
          * Test for Failure
          */
-        $this->assertEquals(false, $dateValidator->isValid("2022-13-04 11:31:52.680"));
-        $this->assertEquals(false, $dateValidator->isValid("-0001-13-04 00:00:00"));
-        $this->assertEquals(false, $dateValidator->isValid("0000-00-00 00:00:00"));
-        $this->assertEquals(false, $dateValidator->isValid("10000-01-01 00:00:00"));
+        $this->assertEquals(false, $dateValidator->isValid('2022-13-04 11:31:52.680'));
+        $this->assertEquals(false, $dateValidator->isValid('-0001-13-04 00:00:00'));
+        $this->assertEquals(false, $dateValidator->isValid('0000-00-00 00:00:00'));
+        $this->assertEquals(false, $dateValidator->isValid('10000-01-01 00:00:00'));
     }
 
-    public function testPastDateValidation(): void
+    public function test_past_date_validation(): void
     {
         $dateValidator = new DatetimeValidator(
             $this->minAllowed,
@@ -92,7 +89,7 @@ public function testPastDateValidation(): void
         $this->assertEquals("Value must be valid date between {$this->minString} and {$this->maxString}.", $dateValidator->getDescription());
     }
 
-    public function testDatePrecision(): void
+    public function test_date_precision(): void
     {
         $dateValidator = new DatetimeValidator(
             $this->minAllowed,
@@ -151,7 +148,7 @@ public function testDatePrecision(): void
         $this->assertEquals("Value must be valid date with minutes precision between {$this->minString} and {$this->maxString}.", $dateValidator->getDescription());
     }
 
-    public function testOffset(): void
+    public function test_offset(): void
     {
         $dateValidator = new DatetimeValidator(
             $this->minAllowed,
@@ -191,4 +188,50 @@ public function testOffset(): void
             $this->assertEquals('Offset must be a positive integer.', $e->getMessage());
         }
     }
+
+    public function test_empty_and_non_string_values(): void
+    {
+        $dateValidator = new DatetimeValidator($this->minAllowed, $this->maxAllowed);
+
+        $this->assertFalse($dateValidator->isValid(''));
+        $this->assertFalse($dateValidator->isValid(12345));
+        $this->assertFalse($dateValidator->isValid(null));
+        $this->assertFalse($dateValidator->isValid([]));
+        $this->assertFalse($dateValidator->isValid(false));
+    }
+
+    public function test_year_outside_min_max_range(): void
+    {
+        $dateValidator = new DatetimeValidator(
+            new \DateTime('2000-01-01'),
+            new \DateTime('2050-12-31'),
+        );
+
+        $this->assertFalse($dateValidator->isValid('1999-06-15 12:00:00'));
+        $this->assertFalse($dateValidator->isValid('2051-01-01 00:00:00'));
+        $this->assertTrue($dateValidator->isValid('2025-06-15 12:00:00'));
+    }
+
+    public function test_value_without_four_digit_year(): void
+    {
+        $dateValidator = new DatetimeValidator($this->minAllowed, $this->maxAllowed);
+
+        $this->assertFalse($dateValidator->isValid('noon'));
+        $this->assertFalse($dateValidator->isValid('tomorrow'));
+        $this->assertFalse($dateValidator->isValid('next Monday'));
+    }
+
+    public function test_is_array(): void
+    {
+        $dateValidator = new DatetimeValidator($this->minAllowed, $this->maxAllowed);
+
+        $this->assertFalse($dateValidator->isArray());
+    }
+
+    public function test_get_type(): void
+    {
+        $dateValidator = new DatetimeValidator($this->minAllowed, $this->maxAllowed);
+
+        $this->assertEquals('string', $dateValidator->getType());
+    }
 }
diff --git a/tests/unit/Validator/DocumentQueriesTest.php b/tests/unit/Validator/DocumentQueriesTest.php
index 558d0b455d..edbfb7f7b0 100644
--- a/tests/unit/Validator/DocumentQueriesTest.php
+++ b/tests/unit/Validator/DocumentQueriesTest.php
@@ -4,63 +4,57 @@
 
 use Exception;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
-use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Queries\Document as DocumentQueries;
+use Utopia\Query\Schema\ColumnType;
 
 class DocumentQueriesTest extends TestCase
 {
     /**
-     * @var array<string, mixed>
+     * @var array<Document>
      */
-    protected array $collection = [];
+    protected array $attributes = [];
 
     /**
      * @throws Exception
      */
-    public function setUp(): void
-    {
-        $this->collection = [
-            '$collection' => ID::custom(Database::METADATA),
-            '$id' => ID::custom('movies'),
-            'name' => 'movies',
-            'attributes' => [
-                new Document([
-                    '$id' => 'title',
-                    'key' => 'title',
-                    'type' => Database::VAR_STRING,
-                    'size' => 256,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'price',
-                    'key' => 'price',
-                    'type' => Database::VAR_FLOAT,
-                    'size' => 5,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ]
+    protected function setUp(): void
+    {
+        $this->attributes = [
+            new Document([
+                '$id' => 'title',
+                'key' => 'title',
+                'type' => ColumnType::String->value,
+                'size' => 256,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'price',
+                'key' => 'price',
+                'type' => ColumnType::Double->value,
+                'size' => 5,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
         ];
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws Exception
      */
-    public function testValidQueries(): void
+    public function test_valid_queries(): void
     {
-        $validator = new DocumentQueries($this->collection['attributes']);
+        $validator = new DocumentQueries($this->attributes);
 
         $queries = [
             Query::select(['title']),
@@ -75,10 +69,176 @@ public function testValidQueries(): void
     /**
      * @throws Exception
      */
-    public function testInvalidQueries(): void
+    public function test_invalid_queries(): void
     {
-        $validator = new DocumentQueries($this->collection['attributes']);
+        $validator = new DocumentQueries($this->attributes);
         $queries = [Query::limit(1)];
         $this->assertEquals(false, $validator->isValid($queries));
     }
+
+    public function testJoinIsValid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::join('orders', '$id', 'customerId'),
+        ]), $validator->getDescription());
+    }
+
+    public function testSelectWithJoinAliasIsValid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::select(['ord.amount']),
+            Query::join('orders', '$id', 'customerId', '=', 'ord'),
+        ]), $validator->getDescription());
+    }
+
+    public function testSelectUnprefixedJoinAttributeIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([
+            Query::select(['score']),
+            Query::leftJoin('reviews', '$id', 'prod_uid'),
+        ]));
+        $this->assertSame('Invalid query: Attribute not found in schema: score', $validator->getDescription());
+    }
+
+    public function testSelectWithLeftJoinAliasIsValid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::select(['rev.score']),
+            Query::leftJoin('reviews', '$id', 'prod_uid', '=', 'rev'),
+        ]), $validator->getDescription());
+    }
+
+    public function testCountIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([Query::count('*', 'cnt')]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testGroupByIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([Query::groupBy(['name'])]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testHavingIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([
+            Query::having([Query::greaterThan('amount', 1)]),
+        ]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testDistinctIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([Query::distinct()]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testUnionIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([
+            Query::union([Query::equal('name', ['x'])]),
+        ]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testUnionAllIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([
+            Query::unionAll([Query::equal('name', ['x'])]),
+        ]));
+        $this->assertStringContainsString('Invalid query method', $validator->getDescription());
+    }
+
+    public function testNaturalJoinIsInvalid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([Query::naturalJoin('orders')]));
+        $this->assertStringContainsString('Natural joins are not supported', $validator->getDescription());
+    }
+
+    public function testNestedJoinOnIsValid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customerId'),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function testNestedJoinOnWithFilterIsValidWithoutFilterValidator(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customerId'),
+                Query::equal('ord.status', ['paid']),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function testNestedJoinOnRequiresColumns(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(false, $validator->isValid([
+            Query::leftJoin('orders', 'ord', [
+                Query::on('', 'customerId'),
+            ]),
+        ]));
+        $this->assertStringContainsString('Join ON requires left and right columns', $validator->getDescription());
+    }
+
+    public function testSelectWithNestedJoinAliasIsValid(): void
+    {
+        $validator = new DocumentQueries($this->documentAttributes());
+
+        $this->assertSame(true, $validator->isValid([
+            Query::select(['ord.amount']),
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customerId'),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    /**
+     * @return array<Document>
+     */
+    private function documentAttributes(): array
+    {
+        return [
+            new Document([
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+            ]),
+            new Document([
+                'key' => 'amount',
+                'type' => ColumnType::Integer->value,
+            ]),
+        ];
+    }
 }
diff --git a/tests/unit/Validator/DocumentsQueriesTest.php b/tests/unit/Validator/DocumentsQueriesTest.php
index 6530ad2999..7374b0f317 100644
--- a/tests/unit/Validator/DocumentsQueriesTest.php
+++ b/tests/unit/Validator/DocumentsQueriesTest.php
@@ -4,129 +4,130 @@
 
 use Exception;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Queries\Documents;
+use Utopia\Query\Schema\ColumnType;
 
 class DocumentsQueriesTest extends TestCase
 {
     /**
-     * @var array<string, mixed>
+     * @var array<Document>
      */
-    protected array $collection = [];
+    protected array $attributes = [];
+
+    /**
+     * @var array<Document>
+     */
+    protected array $indexes = [];
 
     /**
      * @throws Exception
      */
-    public function setUp(): void
+    protected function setUp(): void
     {
-        $this->collection = [
-            '$id' => Database::METADATA,
-            '$collection' => Database::METADATA,
-            'name' => 'movies',
-            'attributes' => [
-                new Document([
-                    '$id' => 'title',
-                    'key' => 'title',
-                    'type' => Database::VAR_STRING,
-                    'size' => 256,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'description',
-                    'key' => 'description',
-                    'type' => Database::VAR_STRING,
-                    'size' => 1000000,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'rating',
-                    'key' => 'rating',
-                    'type' => Database::VAR_INTEGER,
-                    'size' => 5,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'price',
-                    'key' => 'price',
-                    'type' => Database::VAR_FLOAT,
-                    'size' => 5,
-                    'required' => true,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'is_bool',
-                    'key' => 'is_bool',
-                    'type' => Database::VAR_BOOLEAN,
-                    'size' => 0,
-                    'required' => false,
-                    'signed' => false,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => 'id',
-                    'key' => 'id',
-                    'type' => Database::VAR_ID,
-                    'size' => 0,
-                    'required' => false,
-                    'signed' => false,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('testindex2'),
-                    'type' => 'key',
-                    'attributes' => [
-                        'title',
-                        'description',
-                        'price'
-                    ],
-                    'orders' => [
-                        'ASC',
-                        'DESC'
-                    ],
-                ]),
-                new Document([
-                    '$id' => ID::custom('testindex3'),
-                    'type' => 'fulltext',
-                    'attributes' => [
-                        'title'
-                    ],
-                    'orders' => []
-                ]),
-            ],
+        $this->attributes = [
+            new Document([
+                '$id' => 'title',
+                'key' => 'title',
+                'type' => ColumnType::String->value,
+                'size' => 256,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'description',
+                'key' => 'description',
+                'type' => ColumnType::String->value,
+                'size' => 1000000,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'rating',
+                'key' => 'rating',
+                'type' => ColumnType::Integer->value,
+                'size' => 5,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'price',
+                'key' => 'price',
+                'type' => ColumnType::Double->value,
+                'size' => 5,
+                'required' => true,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'is_bool',
+                'key' => 'is_bool',
+                'type' => ColumnType::Boolean->value,
+                'size' => 0,
+                'required' => false,
+                'signed' => false,
+                'array' => false,
+                'filters' => [],
+            ]),
+            new Document([
+                '$id' => 'id',
+                'key' => 'id',
+                'type' => ColumnType::Id->value,
+                'size' => 0,
+                'required' => false,
+                'signed' => false,
+                'array' => false,
+                'filters' => [],
+            ]),
+        ];
+
+        $this->indexes = [
+            new Document([
+                '$id' => ID::custom('testindex2'),
+                'type' => 'key',
+                'attributes' => [
+                    'title',
+                    'description',
+                    'price',
+                ],
+                'orders' => [
+                    'ASC',
+                    'DESC',
+                ],
+            ]),
+            new Document([
+                '$id' => ID::custom('testindex3'),
+                'type' => 'fulltext',
+                'attributes' => [
+                    'title',
+                ],
+                'orders' => [],
+            ]),
         ];
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws Exception
      */
-    public function testValidQueries(): void
+    public function test_valid_queries(): void
     {
         $validator = new Documents(
-            $this->collection['attributes'],
-            $this->collection['indexes'],
-            Database::VAR_INTEGER
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
         );
 
         $queries = [
@@ -159,12 +160,12 @@ public function testValidQueries(): void
     /**
      * @throws Exception
      */
-    public function testInvalidQueries(): void
+    public function test_invalid_queries(): void
     {
         $validator = new Documents(
-            $this->collection['attributes'],
-            $this->collection['indexes'],
-            Database::VAR_INTEGER
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
         );
 
         $queries = ['{"method":"notEqual","attribute":"title","values":["Iron Man","Ant Man"]}'];
@@ -181,12 +182,74 @@ public function testInvalidQueries(): void
 
         $queries = [Query::limit(-1)];
         $this->assertEquals(false, $validator->isValid($queries));
-        $this->assertEquals('Invalid query: Invalid limit: Value must be a valid range between 1 and ' . number_format(PHP_INT_MAX), $validator->getDescription());
+        $this->assertEquals('Invalid query: Invalid limit: Value must be a valid range between 1 and '.number_format(PHP_INT_MAX), $validator->getDescription());
 
         $queries = [Query::equal('title', [])]; // empty array
         $this->assertEquals(false, $validator->isValid($queries));
         $this->assertEquals('Invalid query: Equal queries require at least one value.', $validator->getDescription());
 
+    }
+
+    public function test_filter_with_join_alias_is_valid(): void
+    {
+        $validator = new Documents(
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::equal('sec.amount', [777]),
+            Query::join('orders', '$id', 'customerId', '=', 'sec'),
+        ]), $validator->getDescription());
+    }
+
+    public function test_order_with_join_alias_is_valid(): void
+    {
+        $validator = new Documents(
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::orderAsc('sec.amount'),
+            Query::join('orders', '$id', 'customerId', '=', 'sec'),
+        ]), $validator->getDescription());
+    }
+
+    public function test_unknown_join_alias_filter_is_invalid(): void
+    {
+        $validator = new Documents(
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
+        );
 
+        $this->assertFalse($validator->isValid([
+            Query::equal('other.amount', [777]),
+            Query::join('orders', '$id', 'customerId', '=', 'sec'),
+        ]));
+        $this->assertSame('Invalid query: Attribute not found in schema: other', $validator->getDescription());
+    }
+
+    public function test_nested_and_or_join_alias_is_valid(): void
+    {
+        $validator = new Documents(
+            $this->attributes,
+            $this->indexes,
+            ColumnType::Integer->value
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::join('meta', '$id', 'mainId', '=', 'meta'),
+            Query::and([
+                Query::equal('title', ['Main']),
+                Query::or([
+                    Query::equal('meta.score', [10]),
+                    Query::equal('rating', [2]),
+                ]),
+            ]),
+        ]), $validator->getDescription());
     }
 }
diff --git a/tests/unit/Validator/IndexTest.php b/tests/unit/Validator/IndexTest.php
index 322973e543..5c1a4eaab1 100644
--- a/tests/unit/Validator/IndexTest.php
+++ b/tests/unit/Validator/IndexTest.php
@@ -4,55 +4,36 @@
 
 use Exception;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Helpers\ID;
-use Utopia\Database\Validator\Index;
+use Utopia\Database\Attribute;
+use Utopia\Database\Index;
+use Utopia\Database\Validator\Index as IndexValidator;
+use Utopia\Query\Schema\Order;
 
 class IndexTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws Exception
      */
-    public function testAttributeNotFound(): void
+    public function test_attribute_not_found(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => ['not_exist'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', format: ''),
+        ];
+
+        $indexes = [
+            Index::key(key: 'index1', attributes: ['not_exist']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('Invalid index attribute "not_exist" not found', $validator->getDescription());
     }
@@ -60,48 +41,19 @@ public function testAttributeNotFound(): void
     /**
      * @throws Exception
      */
-    public function testFulltextWithNonString(): void
+    public function test_fulltext_with_non_string(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('date'),
-                    'type' => Database::VAR_DATETIME,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => false,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => ['datetime'],
-                ]),
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_FULLTEXT,
-                    'attributes' => ['title', 'date'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', format: ''),
+            Attribute::datetime(key: 'date', signed: false, format: '', filters: ['datetime']),
+        ];
+
+        $indexes = [
+            Index::fullText(key: 'index1', attributes: ['title', 'date']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('Attribute "date" cannot be part of a fulltext index, must be of type string', $validator->getDescription());
     }
@@ -109,37 +61,18 @@ public function testFulltextWithNonString(): void
     /**
      * @throws Exception
      */
-    public function testIndexLength(): void
+    public function test_index_length(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 769,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => ['title'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', size: 769, format: ''),
+        ];
+
+        $indexes = [
+            Index::key(key: 'index1', attributes: ['title']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('Index length is longer than the maximum: 768', $validator->getDescription());
     }
@@ -147,93 +80,43 @@ public function testIndexLength(): void
     /**
      * @throws Exception
      */
-    public function testMultipleIndexLength(): void
+    public function test_multiple_index_length(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 256,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('description'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 1024,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_FULLTEXT,
-                    'attributes' => ['title'],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', size: 256, format: ''),
+            Attribute::string(key: 'description', size: 1024, format: ''),
+        ];
+
+        $indexes = [
+            Index::fullText(key: 'index1', attributes: ['title']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertTrue($validator->isValid($index));
 
-        $index = new Document([
-            '$id' => ID::custom('index2'),
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['title', 'description'],
-        ]);
+        $index2 = Index::key(key: 'index2', attributes: ['title', 'description']);
 
-        $collection->setAttribute('indexes', $index, Document::SET_TYPE_APPEND);
-        $this->assertFalse($validator->isValid($index));
+        // Validator does not track new indexes added; just validate the new one
+        $this->assertFalse($validator->isValid($index2));
         $this->assertEquals('Index length is longer than the maximum: 768', $validator->getDescription());
     }
 
     /**
      * @throws Exception
      */
-    public function testEmptyAttributes(): void
+    public function test_empty_attributes(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 769,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => [],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', size: 769, format: ''),
+        ];
+
+        $indexes = [
+            Index::key(key: 'index1'),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('No attributes provided for index', $validator->getDescription());
     }
@@ -241,86 +124,40 @@ public function testEmptyAttributes(): void
     /**
      * @throws Exception
      */
-    public function testObjectIndexValidation(): void
+    public function test_object_index_validation(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('data'),
-                    'type' => Database::VAR_OBJECT,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => false,
-                    'required' => true,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => []
-        ]);
+        $attributes = [
+            Attribute::object(key: 'data', required: true, signed: false, format: ''),
+            Attribute::string(key: 'name', format: ''),
+        ];
+
+        /** @var array<Index> $emptyIndexes */
+        $emptyIndexes = [];
 
         // Validator with supportForObjectIndexes enabled
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, supportForObjectIndexes:true);
+        $validator = new IndexValidator($attributes, $emptyIndexes, 768, [], false, false, false, false, supportForObjectIndexes: true);
 
         // Valid: Object index on single VAR_OBJECT attribute
-        $validIndex = new Document([
-            '$id' => ID::custom('idx_gin_valid'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['data'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validIndex = Index::object(key: 'idx_gin_valid', attributes: ['data']);
         $this->assertTrue($validator->isValid($validIndex));
 
         // Invalid: Object index on non-object attribute
-        $invalidIndexType = new Document([
-            '$id' => ID::custom('idx_gin_invalid_type'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['name'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidIndexType = Index::object(key: 'idx_gin_invalid_type', attributes: ['name']);
         $this->assertFalse($validator->isValid($invalidIndexType));
         $this->assertStringContainsString('Object index can only be created on object attributes', $validator->getDescription());
 
         // Invalid: Object index on multiple attributes
-        $invalidIndexMulti = new Document([
-            '$id' => ID::custom('idx_gin_multi'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['data', 'name'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidIndexMulti = Index::object(key: 'idx_gin_multi', attributes: ['data', 'name']);
         $this->assertFalse($validator->isValid($invalidIndexMulti));
         $this->assertStringContainsString('Object index can be created on a single object attribute', $validator->getDescription());
 
         // Invalid: Object index with orders
-        $invalidIndexOrder = new Document([
-            '$id' => ID::custom('idx_gin_order'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['data'],
-            'lengths' => [],
-            'orders' => ['asc'],
-        ]);
+        $invalidIndexOrder = Index::object(key: 'idx_gin_order', attributes: ['data'], orders: [Order::Asc]);
         $this->assertFalse($validator->isValid($invalidIndexOrder));
         $this->assertStringContainsString('Object index do not support explicit orders', $validator->getDescription());
 
         // Validator with supportForObjectIndexes disabled should reject GIN
-        $validatorNoSupport = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, false);
+        $validatorNoSupport = new IndexValidator($attributes, $emptyIndexes, 768, [], false, false, false, false, false);
         $this->assertFalse($validatorNoSupport->isValid($validIndex));
         $this->assertEquals('Object indexes are not supported', $validatorNoSupport->getDescription());
     }
@@ -328,150 +165,63 @@ public function testObjectIndexValidation(): void
     /**
      * @throws Exception
      */
-    public function testNestedObjectPathIndexValidation(): void
+    public function test_nested_object_path_index_validation(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('data'),
-                    'type' => Database::VAR_OBJECT,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => false,
-                    'required' => true,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('metadata'),
-                    'type' => Database::VAR_OBJECT,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => false,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => []
-        ]);
+        $attributes = [
+            Attribute::object(key: 'data', required: true, signed: false, format: ''),
+            Attribute::object(key: 'metadata', signed: false, format: ''),
+            Attribute::string(key: 'name', format: ''),
+        ];
+
+        /** @var array<Index> $emptyIndexes */
+        $emptyIndexes = [];
 
         // Validator with supportForObjectIndexes enabled
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, true, true, true, true, supportForObjects:true);
+        $validator = new IndexValidator($attributes, $emptyIndexes, 768, [], false, false, false, false, true, true, true, true, supportForObjects: true);
 
         // InValid: INDEX_OBJECT on nested path (dot notation)
-        $validNestedObjectIndex = new Document([
-            '$id' => ID::custom('idx_nested_object'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['data.key.nestedKey'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validNestedObjectIndex = Index::object(key: 'idx_nested_object', attributes: ['data.key.nestedKey']);
 
         $this->assertFalse($validator->isValid($validNestedObjectIndex));
 
         // Valid: INDEX_UNIQUE on nested path (for Postgres/Mongo)
-        $validNestedUniqueIndex = new Document([
-            '$id' => ID::custom('idx_nested_unique'),
-            'type' => Database::INDEX_UNIQUE,
-            'attributes' => ['data.key.nestedKey'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validNestedUniqueIndex = Index::unique(key: 'idx_nested_unique', attributes: ['data.key.nestedKey']);
         $this->assertTrue($validator->isValid($validNestedUniqueIndex));
 
         // Valid: INDEX_KEY on nested path
-        $validNestedKeyIndex = new Document([
-            '$id' => ID::custom('idx_nested_key'),
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['metadata.user.id'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validNestedKeyIndex = Index::key(key: 'idx_nested_key', attributes: ['metadata.user.id']);
         $this->assertTrue($validator->isValid($validNestedKeyIndex));
 
         // Invalid: Nested path on non-object attribute
-        $invalidNestedPath = new Document([
-            '$id' => ID::custom('idx_invalid_nested'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['name.key'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidNestedPath = Index::object(key: 'idx_invalid_nested', attributes: ['name.key']);
         $this->assertFalse($validator->isValid($invalidNestedPath));
         $this->assertStringContainsString('Index attribute "name.key" is only supported on object attributes', $validator->getDescription());
 
         // Invalid: Nested path with non-existent base attribute
-        $invalidBaseAttribute = new Document([
-            '$id' => ID::custom('idx_invalid_base'),
-            'type' => Database::INDEX_OBJECT,
-            'attributes' => ['nonexistent.key'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidBaseAttribute = Index::object(key: 'idx_invalid_base', attributes: ['nonexistent.key']);
         $this->assertFalse($validator->isValid($invalidBaseAttribute));
         $this->assertStringContainsString('Invalid index attribute', $validator->getDescription());
 
         // Valid: Multiple nested paths in same index
-        $validMultiNested = new Document([
-            '$id' => ID::custom('idx_multi_nested'),
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['data.key1', 'data.key2'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validMultiNested = Index::key(key: 'idx_multi_nested', attributes: ['data.key1', 'data.key2']);
         $this->assertTrue($validator->isValid($validMultiNested));
     }
 
     /**
      * @throws Exception
      */
-    public function testDuplicatedAttributes(): void
+    public function test_duplicated_attributes(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_FULLTEXT,
-                    'attributes' => ['title', 'title'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', format: ''),
+        ];
+
+        $indexes = [
+            Index::fullText(key: 'index1', attributes: ['title', 'title']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('Duplicate attributes provided', $validator->getDescription());
     }
@@ -479,233 +229,108 @@ public function testDuplicatedAttributes(): void
     /**
      * @throws Exception
      */
-    public function testDuplicatedAttributesDifferentOrder(): void
+    public function test_duplicated_attributes_different_order(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_FULLTEXT,
-                    'attributes' => ['title', 'title'],
-                    'lengths' => [],
-                    'orders' => ['asc', 'desc'],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', format: ''),
+        ];
+
+        $indexes = [
+            Index::fullText(key: 'index1', attributes: ['title', 'title'], orders: [Order::Asc, Order::Desc]),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
     }
 
     /**
      * @throws Exception
      */
-    public function testReservedIndexKey(): void
+    public function test_reserved_index_key(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ])
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('primary'),
-                    'type' => Database::INDEX_FULLTEXT,
-                    'attributes' => ['title'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes'), 768, ['PRIMARY']);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', format: ''),
+        ];
+
+        $indexes = [
+            Index::fullText(key: 'primary', attributes: ['title']),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768, ['PRIMARY']);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
     }
 
     /**
      * @throws Exception
-    */
-    public function testIndexWithNoAttributeSupport(): void
+     */
+    public function test_index_with_no_attribute_support(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('title'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 769,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => [
-                new Document([
-                    '$id' => ID::custom('index1'),
-                    'type' => Database::INDEX_KEY,
-                    'attributes' => ['new'],
-                    'lengths' => [],
-                    'orders' => [],
-                ]),
-            ],
-        ]);
-
-        $validator = new Index(attributes: $collection->getAttribute('attributes'), indexes: $collection->getAttribute('indexes'), maxLength: 768);
-        $index = $collection->getAttribute('indexes')[0];
+        $attributes = [
+            Attribute::string(key: 'title', size: 769, format: ''),
+        ];
+
+        $indexes = [
+            Index::key(key: 'index1', attributes: ['new']),
+        ];
+
+        $validator = new IndexValidator(attributes: $attributes, indexes: $indexes, maxLength: 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
 
-        $validator = new Index(attributes: $collection->getAttribute('attributes'), indexes: $collection->getAttribute('indexes'), maxLength: 768, supportForAttributes: false);
-        $index = $collection->getAttribute('indexes')[0];
+        $validator = new IndexValidator(attributes: $attributes, indexes: $indexes, maxLength: 768, supportForAttributes: false);
+        $index = $indexes[0];
         $this->assertTrue($validator->isValid($index));
     }
 
     /**
      * @throws Exception
      */
-    public function testTrigramIndexValidation(): void
+    public function test_trigram_index_validation(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('description'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 512,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-                new Document([
-                    '$id' => ID::custom('age'),
-                    'type' => Database::VAR_INTEGER,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => []
-        ]);
+        $attributes = [
+            Attribute::string(key: 'name', format: ''),
+            Attribute::string(key: 'description', size: 512, format: ''),
+            Attribute::integer(key: 'age', format: ''),
+        ];
+
+        /** @var array<Index> $emptyIndexes */
+        $emptyIndexes = [];
 
         // Validator with supportForTrigramIndexes enabled
-        $validator = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, false, false, false, false, supportForTrigramIndexes: true);
+        $validator = new IndexValidator($attributes, $emptyIndexes, 768, [], false, false, false, false, false, false, false, false, supportForTrigramIndexes: true);
 
         // Valid: Trigram index on single VAR_STRING attribute
-        $validIndex = new Document([
-            '$id' => ID::custom('idx_trigram_valid'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['name'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validIndex = Index::trigram(key: 'idx_trigram_valid', attributes: ['name']);
         $this->assertTrue($validator->isValid($validIndex));
 
         // Valid: Trigram index on multiple string attributes
-        $validIndexMulti = new Document([
-            '$id' => ID::custom('idx_trigram_multi_valid'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['name', 'description'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $validIndexMulti = Index::trigram(key: 'idx_trigram_multi_valid', attributes: ['name', 'description']);
         $this->assertTrue($validator->isValid($validIndexMulti));
 
         // Invalid: Trigram index on non-string attribute
-        $invalidIndexType = new Document([
-            '$id' => ID::custom('idx_trigram_invalid_type'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['age'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidIndexType = Index::trigram(key: 'idx_trigram_invalid_type', attributes: ['age']);
         $this->assertFalse($validator->isValid($invalidIndexType));
         $this->assertStringContainsString('Trigram index can only be created on string type attributes', $validator->getDescription());
 
         // Invalid: Trigram index with mixed string and non-string attributes
-        $invalidIndexMixed = new Document([
-            '$id' => ID::custom('idx_trigram_mixed'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['name', 'age'],
-            'lengths' => [],
-            'orders' => [],
-        ]);
+        $invalidIndexMixed = Index::trigram(key: 'idx_trigram_mixed', attributes: ['name', 'age']);
         $this->assertFalse($validator->isValid($invalidIndexMixed));
         $this->assertStringContainsString('Trigram index can only be created on string type attributes', $validator->getDescription());
 
         // Invalid: Trigram index with orders
-        $invalidIndexOrder = new Document([
-            '$id' => ID::custom('idx_trigram_order'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['name'],
-            'lengths' => [],
-            'orders' => ['asc'],
-        ]);
+        $invalidIndexOrder = Index::trigram(key: 'idx_trigram_order', attributes: ['name'], orders: [Order::Asc]);
         $this->assertFalse($validator->isValid($invalidIndexOrder));
         $this->assertStringContainsString('Trigram indexes do not support orders or lengths', $validator->getDescription());
 
         // Invalid: Trigram index with lengths
-        $invalidIndexLength = new Document([
-            '$id' => ID::custom('idx_trigram_length'),
-            'type' => Database::INDEX_TRIGRAM,
-            'attributes' => ['name'],
-            'lengths' => [128],
-            'orders' => [],
-        ]);
+        $invalidIndexLength = Index::trigram(key: 'idx_trigram_length', attributes: ['name'], lengths: [128]);
         $this->assertFalse($validator->isValid($invalidIndexLength));
         $this->assertStringContainsString('Trigram indexes do not support orders or lengths', $validator->getDescription());
 
         // Validator with supportForTrigramIndexes disabled should reject trigram
-        $validatorNoSupport = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, false, false, false, false, false);
+        $validatorNoSupport = new IndexValidator($attributes, $emptyIndexes, 768, [], false, false, false, false, false, false, false, false, false);
         $this->assertFalse($validatorNoSupport->isValid($validIndex));
         $this->assertEquals('Trigram indexes are not supported', $validatorNoSupport->getDescription());
     }
@@ -713,42 +338,20 @@ public function testTrigramIndexValidation(): void
     /**
      * @throws Exception
      */
-    public function testTTLIndexValidation(): void
+    public function test_ttl_index_validation(): void
     {
-        $collection = new Document([
-            '$id' => ID::custom('test'),
-            'name' => 'test',
-            'attributes' => [
-                new Document([
-                    '$id' => ID::custom('expiresAt'),
-                    'type' => Database::VAR_DATETIME,
-                    'format' => '',
-                    'size' => 0,
-                    'signed' => false,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => ['datetime'],
-                ]),
-                new Document([
-                    '$id' => ID::custom('name'),
-                    'type' => Database::VAR_STRING,
-                    'format' => '',
-                    'size' => 255,
-                    'signed' => true,
-                    'required' => false,
-                    'default' => null,
-                    'array' => false,
-                    'filters' => [],
-                ]),
-            ],
-            'indexes' => []
-        ]);
+        $attributes = [
+            Attribute::datetime(key: 'expiresAt', signed: false, format: '', filters: ['datetime']),
+            Attribute::string(key: 'name', format: ''),
+        ];
+
+        /** @var array<Index> $emptyIndexes */
+        $emptyIndexes = [];
 
         // Validator with supportForTTLIndexes enabled
-        $validator = new Index(
-            $collection->getAttribute('attributes'),
-            $collection->getAttribute('indexes', []),
+        $validator = new IndexValidator(
+            $attributes,
+            $emptyIndexes,
             768,
             [],
             false, // supportForArrayIndexes
@@ -768,80 +371,38 @@ public function testTTLIndexValidation(): void
         );
 
         // Valid: TTL index on single datetime attribute with valid TTL
-        $validIndex = new Document([
-            '$id' => ID::custom('idx_ttl_valid'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 3600,
-        ]);
+        $validIndex = Index::ttl(key: 'idx_ttl_valid', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 3600);
         $this->assertTrue($validator->isValid($validIndex));
 
-        // Invalid: TTL index with ttl = 1
-        $invalidIndexZero = new Document([
-            '$id' => ID::custom('idx_ttl_zero'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 0,
-        ]);
+        // Invalid: TTL index with ttl = 0
+        $invalidIndexZero = Index::ttl(key: 'idx_ttl_zero', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 0);
         $this->assertFalse($validator->isValid($invalidIndexZero));
         $this->assertEquals('TTL must be at least 1 second', $validator->getDescription());
 
         // Invalid: TTL index with TTL < 0
-        $invalidIndexNegative = new Document([
-            '$id' => ID::custom('idx_ttl_negative'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => -100,
-        ]);
+        $invalidIndexNegative = Index::ttl(key: 'idx_ttl_negative', attributes: ['expiresAt'], orders: [Order::Asc], ttl: -100);
         $this->assertFalse($validator->isValid($invalidIndexNegative));
         $this->assertEquals('TTL must be at least 1 second', $validator->getDescription());
 
         // Invalid: TTL index on non-datetime attribute
-        $invalidIndexType = new Document([
-            '$id' => ID::custom('idx_ttl_invalid_type'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['name'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 3600,
-        ]);
+        $invalidIndexType = Index::ttl(key: 'idx_ttl_invalid_type', attributes: ['name'], orders: [Order::Asc], ttl: 3600);
         $this->assertFalse($validator->isValid($invalidIndexType));
         $this->assertStringContainsString('TTL index can only be created on datetime attributes', $validator->getDescription());
 
         // Invalid: TTL index on multiple attributes
-        $invalidIndexMulti = new Document([
-            '$id' => ID::custom('idx_ttl_multi'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt', 'name'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC, Database::ORDER_ASC],
-            'ttl' => 3600,
-        ]);
+        $invalidIndexMulti = Index::ttl(key: 'idx_ttl_multi', attributes: ['expiresAt', 'name'], orders: [Order::Asc, Order::Asc], ttl: 3600);
         $this->assertFalse($validator->isValid($invalidIndexMulti));
         $this->assertStringContainsString('TTL indexes must be created on a single datetime attribute', $validator->getDescription());
 
         // Valid: TTL index with minimum valid TTL (1 second)
-        $validIndexMin = new Document([
-            '$id' => ID::custom('idx_ttl_min'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 1,
-        ]);
+        $validIndexMin = Index::ttl(key: 'idx_ttl_min', attributes: ['expiresAt'], orders: [Order::Asc]);
         $this->assertTrue($validator->isValid($validIndexMin));
 
         // Invalid: any additional TTL index when another TTL index already exists
-        $collection->setAttribute('indexes', $validIndex, Document::SET_TYPE_APPEND);
-        $validatorWithExisting = new Index(
-            $collection->getAttribute('attributes'),
-            $collection->getAttribute('indexes', []),
+        $indexesWithTTL = [$validIndex];
+        $validatorWithExisting = new IndexValidator(
+            $attributes,
+            $indexesWithTTL,
             768,
             [],
             false, // supportForArrayIndexes
@@ -860,19 +421,12 @@ public function testTTLIndexValidation(): void
             true   // supportForTTLIndexes
         );
 
-        $duplicateTTLIndex = new Document([
-            '$id' => ID::custom('idx_ttl_duplicate'),
-            'type' => Database::INDEX_TTL,
-            'attributes' => ['expiresAt'],
-            'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200,
-        ]);
+        $duplicateTTLIndex = Index::ttl(key: 'idx_ttl_duplicate', attributes: ['expiresAt'], orders: [Order::Asc], ttl: 7200);
         $this->assertFalse($validatorWithExisting->isValid($duplicateTTLIndex));
         $this->assertEquals('There can be only one TTL index in a collection', $validatorWithExisting->getDescription());
 
-        // Validator with supportForTrigramIndexes disabled should reject TTL
-        $validatorNoSupport = new Index($collection->getAttribute('attributes'), $collection->getAttribute('indexes', []), 768, [], false, false, false, false, false, false, false, false, false);
+        // Validator with supportForTTLIndexes disabled should reject TTL
+        $validatorNoSupport = new IndexValidator($attributes, $indexesWithTTL, 768, [], false, false, false, false, false, false, false, false, false);
         $this->assertFalse($validatorNoSupport->isValid($validIndex));
         $this->assertEquals('TTL indexes are not supported', $validatorNoSupport->getDescription());
     }
diff --git a/tests/unit/Validator/IndexedQueriesTest.php b/tests/unit/Validator/IndexedQueriesTest.php
index 409fcf3653..05fbaacb4e 100644
--- a/tests/unit/Validator/IndexedQueriesTest.php
+++ b/tests/unit/Validator/IndexedQueriesTest.php
@@ -3,42 +3,44 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\IndexedQueries;
 use Utopia\Database\Validator\Query\Cursor;
 use Utopia\Database\Validator\Query\Filter;
+use Utopia\Database\Validator\Query\Join;
 use Utopia\Database\Validator\Query\Limit;
 use Utopia\Database\Validator\Query\Offset;
 use Utopia\Database\Validator\Query\Order;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 class IndexedQueriesTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testEmptyQueries(): void
+    public function test_empty_queries(): void
     {
         $validator = new IndexedQueries();
 
         $this->assertEquals(true, $validator->isValid([]));
     }
 
-    public function testInvalidQuery(): void
+    public function test_invalid_query(): void
     {
         $validator = new IndexedQueries();
 
-        $this->assertEquals(false, $validator->isValid(["this.is.invalid"]));
+        $this->assertEquals(false, $validator->isValid(['this.is.invalid']));
     }
 
-    public function testInvalidMethod(): void
+    public function test_invalid_method(): void
     {
         $validator = new IndexedQueries();
         $this->assertEquals(false, $validator->isValid(['equal("attr", "value")']));
@@ -47,30 +49,30 @@ public function testInvalidMethod(): void
         $this->assertEquals(false, $validator->isValid(['equal("attr", "value")']));
     }
 
-    public function testInvalidValue(): void
+    public function test_invalid_value(): void
     {
         $validator = new IndexedQueries([], [], [new Limit()]);
         $this->assertEquals(false, $validator->isValid(['limit(-1)']));
     }
 
-    public function testValid(): void
+    public function test_valid(): void
     {
         $attributes = [
             new Document([
                 '$id' => 'name',
                 'key' => 'name',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
         ];
 
         $indexes = [
             new Document([
-                'type' => Database::INDEX_KEY,
+                'type' => IndexType::Key->value,
                 'attributes' => ['name'],
             ]),
             new Document([
-                'type' => Database::INDEX_FULLTEXT,
+                'type' => IndexType::Fulltext->value,
                 'attributes' => ['name'],
             ]),
         ];
@@ -80,10 +82,10 @@ public function testValid(): void
             $indexes,
             [
                 new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
+                new Filter($attributes, ColumnType::Integer->value),
                 new Limit(),
                 new Offset(),
-                new Order($attributes)
+                new Order($attributes),
             ]
         );
 
@@ -121,19 +123,19 @@ public function testValid(): void
         $this->assertEquals(true, $validator->isValid([$query]));
     }
 
-    public function testMissingIndex(): void
+    public function test_missing_index(): void
     {
         $attributes = [
             new Document([
                 'key' => 'name',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
         ];
 
         $indexes = [
             new Document([
-                'type' => Database::INDEX_KEY,
+                'type' => IndexType::Key->value,
                 'attributes' => ['name'],
             ]),
         ];
@@ -143,10 +145,10 @@ public function testMissingIndex(): void
             $indexes,
             [
                 new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
+                new Filter($attributes, ColumnType::Integer->value),
                 new Limit(),
                 new Offset(),
-                new Order($attributes)
+                new Order($attributes),
             ]
         );
 
@@ -167,27 +169,163 @@ public function testMissingIndex(): void
         $this->assertEquals('Searching by attribute "name" requires a fulltext index.', $validator->getDescription());
     }
 
-    public function testTwoAttributesFulltext(): void
+    public function test_join_side_search_skips_main_fulltext_index(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [
+                new Filter($attributes, ColumnType::Integer->value),
+                new Join(),
+            ]
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::leftJoin('meta', '$id', 'mainId', '=', 'meta'),
+            Query::search('meta.body', 'needle'),
+        ]), $validator->getDescription());
+
+        $this->assertFalse($validator->isValid([
+            Query::search('name', 'needle'),
+        ]));
+        $this->assertSame(
+            'Searching by attribute "name" requires a fulltext index.',
+            $validator->getDescription()
+        );
+    }
+
+    public function testNestedJoinOnSearchRequiresFulltextIndex(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [
+                new Filter($attributes, ColumnType::Integer->value),
+                new Join(),
+            ]
+        );
+
+        $this->assertFalse($validator->isValid([
+            Query::leftJoin('meta', 'meta', [
+                Query::on('$id', 'mainId'),
+                Query::search('name', 'needle'),
+            ]),
+        ]));
+        $this->assertSame(
+            'Searching by attribute "name" requires a fulltext index.',
+            $validator->getDescription()
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::leftJoin('meta', 'meta', [
+                Query::on('$id', 'mainId'),
+                Query::search('meta.body', 'needle'),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function testNestedJoinOnVectorCountsTowardLimit(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'embedding',
+                'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => 3,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [
+                new Filter($attributes, ColumnType::Integer->value),
+                new Join(),
+            ]
+        );
+
+        $this->assertFalse($validator->isValid([
+            Query::vectorDot('embedding', [0.1, 0.2, 0.3]),
+            Query::leftJoin('meta', 'meta', [
+                Query::on('$id', 'mainId'),
+                Query::vectorCosine('embedding', [0.3, 0.4, 0.5]),
+            ]),
+        ]));
+        $this->assertSame(
+            'Cannot use multiple vector queries in a single request',
+            $validator->getDescription()
+        );
+    }
+
+    public function testNestedJoinOnSingleVectorIsValid(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'embedding',
+                'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => 3,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [
+                new Filter($attributes, ColumnType::Integer->value),
+                new Join(),
+            ]
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::leftJoin('meta', 'meta', [
+                Query::on('$id', 'mainId'),
+                Query::vectorCosine('embedding', [0.3, 0.4, 0.5]),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function test_two_attributes_fulltext(): void
     {
         $attributes = [
             new Document([
                 '$id' => 'ft1',
                 'key' => 'ft1',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
             new Document([
                 '$id' => 'ft2',
                 'key' => 'ft2',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
         ];
 
         $indexes = [
             new Document([
-                'type' => Database::INDEX_FULLTEXT,
-                'attributes' => ['ft1','ft2'],
+                'type' => IndexType::Fulltext->value,
+                'attributes' => ['ft1', 'ft2'],
             ]),
         ];
 
@@ -196,18 +334,17 @@ public function testTwoAttributesFulltext(): void
             $indexes,
             [
                 new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
+                new Filter($attributes, ColumnType::Integer->value),
                 new Limit(),
                 new Offset(),
-                new Order($attributes)
+                new Order($attributes),
             ]
         );
 
         $this->assertEquals(false, $validator->isValid([Query::search('ft1', 'value')]));
     }
 
-
-    public function testJsonParse(): void
+    public function test_json_parse(): void
     {
         try {
             Query::parse('{"method":"equal","attribute":"name","values":["value"]'); // broken Json;
@@ -216,4 +353,145 @@ public function testJsonParse(): void
             $this->assertEquals('Invalid query: Syntax error', $e->getMessage());
         }
     }
+
+    public function test_single_vector_query_passes(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'embedding',
+                'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => 3,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [new Filter($attributes, ColumnType::Integer->value)]
+        );
+
+        $vectorQuery = Query::vectorCosine('embedding', [0.1, 0.2, 0.3]);
+        $this->assertTrue($validator->isValid([$vectorQuery]));
+    }
+
+    public function test_nested_queries_containing_vector_methods(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'embedding',
+                'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => 3,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [new Filter($attributes, ColumnType::Integer->value)]
+        );
+
+        $orQuery = Query::or([
+            Query::equal('name', ['alice']),
+            Query::equal('name', ['bob']),
+        ]);
+        $vectorQuery = Query::vectorDot('embedding', [0.1, 0.2, 0.3]);
+        $this->assertTrue($validator->isValid([$orQuery, $vectorQuery]));
+    }
+
+    public function test_unparseable_string_query_returns_error(): void
+    {
+        $validator = new IndexedQueries([], [], [new Limit()]);
+
+        $this->assertFalse($validator->isValid(['totally broken }{']));
+        $this->assertStringContainsString('Invalid query', $validator->getDescription());
+    }
+
+    public function test_nested_non_having_with_invalid_sub_queries(): void
+    {
+        $validator = new IndexedQueries([], [], [new Filter([], ColumnType::Integer->value)]);
+
+        $nestedOr = Query::or([Query::equal('nonexistent', ['value'])]);
+        $this->assertFalse($validator->isValid([$nestedOr]));
+    }
+
+    public function test_nested_search_requires_fulltext_index(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'title',
+                'key' => 'title',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $indexes = [
+            new Document([
+                'type' => IndexType::Fulltext->value,
+                'attributes' => ['title'],
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            $indexes,
+            [new Filter($attributes, ColumnType::Integer->value)]
+        );
+
+        $this->assertTrue($validator->isValid([
+            Query::or([
+                Query::search('title', 'foo'),
+                Query::equal('name', ['bar']),
+            ]),
+        ]));
+
+        $this->assertFalse($validator->isValid([
+            Query::or([
+                Query::search('name', 'foo'),
+                Query::equal('title', ['bar']),
+            ]),
+        ]));
+        $this->assertEquals('Searching by attribute "name" requires a fulltext index.', $validator->getDescription());
+    }
+
+    public function test_multiple_vector_queries_fails(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'embedding',
+                'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => 3,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new IndexedQueries(
+            $attributes,
+            [],
+            [new Filter($attributes, ColumnType::Integer->value)]
+        );
+
+        $vectorQuery1 = Query::vectorCosine('embedding', [0.1, 0.2, 0.3]);
+        $vectorQuery2 = Query::vectorEuclidean('embedding', [0.4, 0.5, 0.6]);
+
+        $this->assertFalse($validator->isValid([$vectorQuery1, $vectorQuery2]));
+        $this->assertEquals('Cannot use multiple vector queries in a single request', $validator->getDescription());
+    }
 }
diff --git a/tests/unit/Validator/KeyTest.php b/tests/unit/Validator/KeyTest.php
index 3c19346d81..fbc8d1ddfa 100644
--- a/tests/unit/Validator/KeyTest.php
+++ b/tests/unit/Validator/KeyTest.php
@@ -7,21 +7,18 @@
 
 class KeyTest extends TestCase
 {
-    /**
-     * @var Key
-     */
-    protected ?Key $object = null;
+    protected Key $object;
 
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->object = new Key();
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testValues(): void
+    public function test_values(): void
     {
         // Must be strings
         $this->assertEquals(false, $this->object->isValid(false));
diff --git a/tests/unit/Validator/LabelTest.php b/tests/unit/Validator/LabelTest.php
index a6dd50bef9..2bc93420d7 100644
--- a/tests/unit/Validator/LabelTest.php
+++ b/tests/unit/Validator/LabelTest.php
@@ -7,21 +7,18 @@
 
 class LabelTest extends TestCase
 {
-    /**
-     * @var Label
-     */
-    protected ?Label $object = null;
+    protected Label $object;
 
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->object = new Label();
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testValues(): void
+    public function test_values(): void
     {
         // Must be strings
         $this->assertEquals(false, $this->object->isValid(false));
@@ -62,4 +59,14 @@ public function testValues(): void
         $this->assertEquals(true, $this->object->isValid(str_repeat('a', 36)));
         $this->assertEquals(false, $this->object->isValid(str_repeat('a', 256)));
     }
+
+    public function test_non_string_values_rejected(): void
+    {
+        $this->assertFalse($this->object->isValid(42));
+        $this->assertFalse($this->object->isValid(null));
+        $this->assertFalse($this->object->isValid(['abc']));
+        $this->assertFalse($this->object->isValid(true));
+        $this->assertFalse($this->object->isValid(3.14));
+        $this->assertFalse($this->object->isValid(new \stdClass()));
+    }
 }
diff --git a/tests/unit/Validator/ObjectTest.php b/tests/unit/Validator/ObjectTest.php
index 4563fe2eb8..24dc50b6ba 100644
--- a/tests/unit/Validator/ObjectTest.php
+++ b/tests/unit/Validator/ObjectTest.php
@@ -7,7 +7,7 @@
 
 class ObjectTest extends TestCase
 {
-    public function testValidAssociativeObjects(): void
+    public function test_valid_associative_objects(): void
     {
         $validator = new ObjectValidator();
 
@@ -15,9 +15,9 @@ public function testValidAssociativeObjects(): void
         $this->assertTrue($validator->isValid([
             'a' => [
                 'b' => [
-                    'c' => 123
-                ]
-            ]
+                    'c' => 123,
+                ],
+            ],
         ]));
 
         $this->assertTrue($validator->isValid([
@@ -25,28 +25,28 @@ public function testValidAssociativeObjects(): void
             'metadata' => [
                 'rating' => 4.5,
                 'info' => [
-                    'category' => 'science'
-                ]
-            ]
+                    'category' => 'science',
+                ],
+            ],
         ]));
 
         $this->assertTrue($validator->isValid([
             'key1' => null,
-            'key2' => ['nested' => null]
+            'key2' => ['nested' => null],
         ]));
 
         $this->assertTrue($validator->isValid([
-            'meta' => (object)['x' => 1]
+            'meta' => (object) ['x' => 1],
         ]));
 
         $this->assertTrue($validator->isValid([
             'a' => 1,
-            2 => 'b'
+            2 => 'b',
         ]));
 
     }
 
-    public function testInvalidStructures(): void
+    public function test_invalid_structures(): void
     {
         $validator = new ObjectValidator();
 
@@ -55,11 +55,33 @@ public function testInvalidStructures(): void
         $this->assertFalse($validator->isValid('not an array'));
 
         $this->assertFalse($validator->isValid([
-            0 => 'value'
+            0 => 'value',
         ]));
     }
 
-    public function testEmptyCases(): void
+    public function test_scalar_json_strings_are_not_objects(): void
+    {
+        $validator = new ObjectValidator();
+
+        $this->assertFalse($validator->isValid('123'), 'a JSON number is not an object');
+        $this->assertFalse($validator->isValid('0'), 'a falsy JSON number is not an object');
+        $this->assertFalse($validator->isValid('true'), 'a JSON boolean is not an object');
+        $this->assertFalse($validator->isValid('null'), 'JSON null is not an object');
+        $this->assertFalse($validator->isValid('"str"'), 'a JSON string is not an object');
+        $this->assertFalse($validator->isValid('""'), 'an empty JSON string is not an object');
+        $this->assertFalse($validator->isValid('[1, 2]'), 'a JSON list is not an object');
+    }
+
+    public function test_json_object_strings_are_objects(): void
+    {
+        $validator = new ObjectValidator();
+
+        $this->assertTrue($validator->isValid('{"a": 1}'));
+        $this->assertTrue($validator->isValid('{}'));
+        $this->assertTrue($validator->isValid('[]'), 'an empty JSON array matches the empty-array case');
+    }
+
+    public function test_empty_cases(): void
     {
         $validator = new ObjectValidator();
 
diff --git a/tests/unit/Validator/OperatorTest.php b/tests/unit/Validator/OperatorTest.php
index e89d391042..10c1563162 100644
--- a/tests/unit/Validator/OperatorTest.php
+++ b/tests/unit/Validator/OperatorTest.php
@@ -3,16 +3,16 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Operator;
 use Utopia\Database\Validator\Operator as OperatorValidator;
+use Utopia\Query\Schema\ColumnType;
 
 class OperatorTest extends TestCase
 {
     protected Document $collection;
 
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->collection = new Document([
             '$id' => 'test_collection',
@@ -20,50 +20,50 @@ public function setUp(): void
                 new Document([
                     '$id' => 'count',
                     'key' => 'count',
-                    'type' => Database::VAR_INTEGER,
+                    'type' => ColumnType::Integer->value,
                     'array' => false,
                 ]),
                 new Document([
                     '$id' => 'score',
                     'key' => 'score',
-                    'type' => Database::VAR_FLOAT,
+                    'type' => ColumnType::Double->value,
                     'array' => false,
                 ]),
                 new Document([
                     '$id' => 'title',
                     'key' => 'title',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'array' => false,
                     'size' => 100,
                 ]),
                 new Document([
                     '$id' => 'tags',
                     'key' => 'tags',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'array' => true,
                 ]),
                 new Document([
                     '$id' => 'active',
                     'key' => 'active',
-                    'type' => Database::VAR_BOOLEAN,
+                    'type' => ColumnType::Boolean->value,
                     'array' => false,
                 ]),
                 new Document([
                     '$id' => 'createdAt',
                     'key' => 'createdAt',
-                    'type' => Database::VAR_DATETIME,
+                    'type' => ColumnType::Datetime->value,
                     'array' => false,
                 ]),
             ],
         ]);
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     // Test parsing string operators (new functionality)
-    public function testParseStringOperator(): void
+    public function test_parse_string_operator(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -76,7 +76,7 @@ public function testParseStringOperator(): void
         $this->assertTrue($validator->isValid($json), $validator->getDescription());
     }
 
-    public function testParseInvalidStringOperator(): void
+    public function test_parse_invalid_string_operator(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -85,7 +85,7 @@ public function testParseInvalidStringOperator(): void
         $this->assertStringContainsString('Invalid operator:', $validator->getDescription());
     }
 
-    public function testParseStringOperatorWithInvalidMethod(): void
+    public function test_parse_string_operator_with_invalid_method(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -93,7 +93,7 @@ public function testParseStringOperatorWithInvalidMethod(): void
         $invalidOperator = json_encode([
             'method' => 'invalidMethod',
             'attribute' => 'count',
-            'values' => [1]
+            'values' => [1],
         ]);
 
         $this->assertFalse($validator->isValid($invalidOperator));
@@ -101,7 +101,7 @@ public function testParseStringOperatorWithInvalidMethod(): void
     }
 
     // Test numeric operators
-    public function testIncrementOperator(): void
+    public function test_increment_operator(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -111,7 +111,7 @@ public function testIncrementOperator(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testIncrementOnNonNumeric(): void
+    public function test_increment_on_non_numeric(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -122,7 +122,7 @@ public function testIncrementOnNonNumeric(): void
         $this->assertStringContainsString('Cannot apply increment operator to non-numeric field', $validator->getDescription());
     }
 
-    public function testDecrementOperator(): void
+    public function test_decrement_operator(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -132,7 +132,7 @@ public function testDecrementOperator(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testMultiplyOperator(): void
+    public function test_multiply_operator(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -142,7 +142,7 @@ public function testMultiplyOperator(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testDivideByZero(): void
+    public function test_divide_by_zero(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -153,7 +153,7 @@ public function testDivideByZero(): void
         $operator = Operator::divide(0);
     }
 
-    public function testModuloByZero(): void
+    public function test_modulo_by_zero(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -165,7 +165,7 @@ public function testModuloByZero(): void
     }
 
     // Test array operators
-    public function testArrayAppend(): void
+    public function test_array_append(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -175,7 +175,7 @@ public function testArrayAppend(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testArrayAppendOnNonArray(): void
+    public function test_array_append_on_non_array(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -186,7 +186,7 @@ public function testArrayAppendOnNonArray(): void
         $this->assertStringContainsString('Cannot apply arrayAppend operator to non-array field', $validator->getDescription());
     }
 
-    public function testArrayUnique(): void
+    public function test_array_unique(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -196,7 +196,7 @@ public function testArrayUnique(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testArrayUniqueOnNonArray(): void
+    public function test_array_unique_on_non_array(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -207,7 +207,7 @@ public function testArrayUniqueOnNonArray(): void
         $this->assertStringContainsString('Cannot apply arrayUnique operator to non-array field', $validator->getDescription());
     }
 
-    public function testArrayIntersect(): void
+    public function test_array_intersect(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -217,7 +217,7 @@ public function testArrayIntersect(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testArrayIntersectWithEmptyArray(): void
+    public function test_array_intersect_with_empty_array(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -228,7 +228,7 @@ public function testArrayIntersectWithEmptyArray(): void
         $this->assertStringContainsString('requires a non-empty array value', $validator->getDescription());
     }
 
-    public function testArrayDiff(): void
+    public function test_array_diff(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -238,7 +238,7 @@ public function testArrayDiff(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testArrayFilter(): void
+    public function test_array_filter(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -248,7 +248,7 @@ public function testArrayFilter(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testArrayFilterInvalidCondition(): void
+    public function test_array_filter_invalid_condition(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -260,7 +260,7 @@ public function testArrayFilterInvalidCondition(): void
     }
 
     // Test string operators
-    public function testStringConcat(): void
+    public function test_string_concat(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -270,7 +270,7 @@ public function testStringConcat(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testStringConcatOnNonString(): void
+    public function test_string_concat_on_non_string(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -281,7 +281,7 @@ public function testStringConcatOnNonString(): void
         $this->assertStringContainsString('Cannot apply stringConcat operator to non-string field', $validator->getDescription());
     }
 
-    public function testStringReplace(): void
+    public function test_string_replace(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -292,7 +292,7 @@ public function testStringReplace(): void
     }
 
     // Test boolean operators
-    public function testToggle(): void
+    public function test_toggle(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -302,7 +302,7 @@ public function testToggle(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testToggleOnNonBoolean(): void
+    public function test_toggle_on_non_boolean(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -314,7 +314,7 @@ public function testToggleOnNonBoolean(): void
     }
 
     // Test date operators
-    public function testDateAddDays(): void
+    public function test_date_add_days(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -324,7 +324,7 @@ public function testDateAddDays(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testDateAddDaysOnNonDateTime(): void
+    public function test_date_add_days_on_non_date_time(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -335,7 +335,7 @@ public function testDateAddDaysOnNonDateTime(): void
         $this->assertStringContainsString('Cannot apply dateAddDays operator to non-datetime field', $validator->getDescription());
     }
 
-    public function testDateSubDays(): void
+    public function test_date_sub_days(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -345,7 +345,7 @@ public function testDateSubDays(): void
         $this->assertTrue($validator->isValid($operator), $validator->getDescription());
     }
 
-    public function testDateSubDaysOnNonDateTime(): void
+    public function test_date_sub_days_on_non_date_time(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -356,7 +356,7 @@ public function testDateSubDaysOnNonDateTime(): void
         $this->assertStringContainsString('Cannot apply dateSubDays operator to non-datetime field', $validator->getDescription());
     }
 
-    public function testDateSetNow(): void
+    public function test_date_set_now(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -367,7 +367,7 @@ public function testDateSetNow(): void
     }
 
     // Test attribute validation
-    public function testNonExistentAttribute(): void
+    public function test_non_existent_attribute(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -379,7 +379,7 @@ public function testNonExistentAttribute(): void
     }
 
     // Test multiple operators as strings (like Query validator does)
-    public function testMultipleStringOperators(): void
+    public function test_multiple_string_operators(): void
     {
         $validator = new OperatorValidator($this->collection);
 
@@ -397,7 +397,7 @@ public function testMultipleStringOperators(): void
         foreach ($operators as $index => $operator) {
             $operator->setAttribute($attributes[$index]);
             $json = $operator->toString();
-            $this->assertTrue($validator->isValid($json), "Failed for operator {$attributes[$index]}: " . $validator->getDescription());
+            $this->assertTrue($validator->isValid($json), "Failed for operator {$attributes[$index]}: ".$validator->getDescription());
         }
     }
 }
diff --git a/tests/unit/Validator/PermissionsTest.php b/tests/unit/Validator/PermissionsTest.php
index d574644633..96a5fd47b5 100644
--- a/tests/unit/Validator/PermissionsTest.php
+++ b/tests/unit/Validator/PermissionsTest.php
@@ -13,18 +13,18 @@
 
 class PermissionsTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws DatabaseException
      */
-    public function testSingleMethodSingleValue(): void
+    public function test_single_method_single_value(): void
     {
         $object = new Permissions();
 
@@ -95,7 +95,7 @@ public function testSingleMethodSingleValue(): void
         $this->assertTrue($object->isValid($document->getPermissions()));
     }
 
-    public function testMultipleMethodSingleValue(): void
+    public function test_multiple_method_single_value(): void
     {
         $object = new Permissions();
 
@@ -120,21 +120,21 @@ public function testMultipleMethodSingleValue(): void
         $document['$permissions'] = [
             Permission::read(Role::user(ID::custom('123abc'))),
             Permission::create(Role::user(ID::custom('123abc'))),
-            Permission::update(Role::user(ID::custom('123abc')))
+            Permission::update(Role::user(ID::custom('123abc'))),
         ];
         $this->assertTrue($object->isValid($document->getPermissions()));
 
         $document['$permissions'] = [
             Permission::read(Role::team(ID::custom('123abc'))),
             Permission::create(Role::team(ID::custom('123abc'))),
-            Permission::update(Role::team(ID::custom('123abc')))
+            Permission::update(Role::team(ID::custom('123abc'))),
         ];
         $this->assertTrue($object->isValid($document->getPermissions()));
 
         $document['$permissions'] = [
             Permission::read(Role::team(ID::custom('123abc'), 'viewer')),
             Permission::create(Role::team(ID::custom('123abc'), 'viewer')),
-            Permission::update(Role::team(ID::custom('123abc'), 'viewer'))
+            Permission::update(Role::team(ID::custom('123abc'), 'viewer')),
         ];
         $this->assertTrue($object->isValid($document->getPermissions()));
 
@@ -153,7 +153,7 @@ public function testMultipleMethodSingleValue(): void
         $this->assertTrue($object->isValid($document->getPermissions()));
     }
 
-    public function testMultipleMethodMultipleValues(): void
+    public function test_multiple_method_multiple_values(): void
     {
         $object = new Permissions();
 
@@ -177,19 +177,19 @@ public function testMultipleMethodMultipleValues(): void
             Permission::create(Role::team(ID::custom('123abc'))),
             Permission::update(Role::user(ID::custom('123abc'))),
             Permission::update(Role::team(ID::custom('123abc'))),
-            Permission::delete(Role::user(ID::custom('123abc')))
+            Permission::delete(Role::user(ID::custom('123abc'))),
         ];
         $this->assertTrue($object->isValid($document->getPermissions()));
         $document['$permissions'] = [
             Permission::read(Role::any()),
             Permission::create(Role::guests()),
             Permission::update(Role::team(ID::custom('123abc'), 'edit')),
-            Permission::delete(Role::team(ID::custom('123abc'), 'edit'))
+            Permission::delete(Role::team(ID::custom('123abc'), 'edit')),
         ];
         $this->assertTrue($object->isValid($document->getPermissions()));
     }
 
-    public function testInvalidPermissions(): void
+    public function test_invalid_permissions(): void
     {
         $object = new Permissions();
 
@@ -239,11 +239,11 @@ public function testInvalidPermissions(): void
 
         // Permission role:$value must be one of: all, guest, member
         $this->assertFalse($object->isValid(['read("anyy")']));
-        $this->assertEquals('Role "anyy" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "anyy" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
         $this->assertFalse($object->isValid(['read("gguest")']));
-        $this->assertEquals('Role "gguest" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "gguest" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
         $this->assertFalse($object->isValid(['read("memer:123abc")']));
-        $this->assertEquals('Role "memer" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "memer" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
 
         // team:$value, member:$value and user:$value must have valid Key for $value
         // No leading special chars
@@ -270,11 +270,11 @@ public function testInvalidPermissions(): void
 
         // Permission role must begin with one of: member, role, team, user
         $this->assertFalse($object->isValid(['update("memmber:1234")']));
-        $this->assertEquals('Role "memmber" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "memmber" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
         $this->assertFalse($object->isValid(['update("tteam:1234")']));
-        $this->assertEquals('Role "tteam" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "tteam" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
         $this->assertFalse($object->isValid(['update("userr:1234")']));
-        $this->assertEquals('Role "userr" is not allowed. Must be one of: ' . \implode(', ', Roles::ROLES) . '.', $object->getDescription());
+        $this->assertEquals('Role "userr" is not allowed. Must be one of: '.\implode(', ', Roles::ROLES).'.', $object->getDescription());
 
         // Team permission
         $this->assertFalse($object->isValid([Permission::read(Role::team(ID::custom('_abcd')))]));
@@ -308,7 +308,7 @@ public function testInvalidPermissions(): void
     /*
      *  Test for checking duplicate methods input. The getPermissions should return an a list array
       */
-    public function testDuplicateMethods(): void
+    public function test_duplicate_methods(): void
     {
         $validator = new Permissions();
 
@@ -327,23 +327,23 @@ public function testDuplicateMethods(): void
             ],
             'title' => 'This is a test.',
             'list' => [
-                'one'
+                'one',
             ],
             'children' => [
                 new Document(['name' => 'x']),
                 new Document(['name' => 'y']),
                 new Document(['name' => 'z']),
-            ]
+            ],
         ]);
         $this->assertTrue($validator->isValid($document->getPermissions()));
         $permissions = $document->getPermissions();
         $this->assertEquals(5, count($permissions));
         $this->assertEquals([
             'read("any")',
-            'read("user:' . $user . '")',
-            'write("user:' . $user . '")',
-            'update("user:' . $user . '")',
-            'delete("user:' . $user . '")',
+            'read("user:'.$user.'")',
+            'write("user:'.$user.'")',
+            'update("user:'.$user.'")',
+            'delete("user:'.$user.'")',
         ], $permissions);
     }
 }
diff --git a/tests/unit/Validator/QueriesTest.php b/tests/unit/Validator/QueriesTest.php
index 40e8d7671b..2e57a6b5cf 100644
--- a/tests/unit/Validator/QueriesTest.php
+++ b/tests/unit/Validator/QueriesTest.php
@@ -4,43 +4,50 @@
 
 use Exception;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Queries;
+use Utopia\Database\Validator\Query\Aggregate;
 use Utopia\Database\Validator\Query\Cursor;
+use Utopia\Database\Validator\Query\Distinct;
 use Utopia\Database\Validator\Query\Filter;
+use Utopia\Database\Validator\Query\GroupBy;
+use Utopia\Database\Validator\Query\Having;
+use Utopia\Database\Validator\Query\Join;
 use Utopia\Database\Validator\Query\Limit;
 use Utopia\Database\Validator\Query\Offset;
 use Utopia\Database\Validator\Query\Order;
+use Utopia\Database\Validator\Query\Select;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 
 class QueriesTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testEmptyQueries(): void
+    public function test_empty_queries(): void
     {
         $validator = new Queries();
 
         $this->assertEquals(true, $validator->isValid([]));
     }
 
-    public function testInvalidMethod(): void
+    public function test_invalid_method(): void
     {
         $validator = new Queries();
-        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
+        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ['value'])]));
 
         $validator = new Queries([new Limit()]);
-        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
+        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ['value'])]));
     }
 
-    public function testInvalidValue(): void
+    public function test_invalid_value(): void
     {
         $validator = new Queries([new Limit()]);
         $this->assertEquals(false, $validator->isValid([Query::limit(-1)]));
@@ -49,19 +56,19 @@ public function testInvalidValue(): void
     /**
      * @throws Exception
      */
-    public function testValid(): void
+    public function test_valid(): void
     {
         $attributes = [
             new Document([
                 '$id' => 'name',
                 'key' => 'name',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
             new Document([
                 '$id' => 'meta',
                 'key' => 'meta',
-                'type' => Database::VAR_OBJECT,
+                'type' => ColumnType::Object->value,
                 'array' => false,
             ]),
         ];
@@ -69,10 +76,10 @@ public function testValid(): void
         $validator = new Queries(
             [
                 new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
+                new Filter($attributes, ColumnType::Integer->value),
                 new Limit(),
                 new Offset(),
-                new Order($attributes)
+                new Order($attributes),
             ]
         );
 
@@ -116,4 +123,398 @@ public function testValid(): void
             ])
         );
     }
+
+    public function test_non_array_value_returns_false(): void
+    {
+        $validator = new Queries();
+
+        $this->assertFalse($validator->isValid('not_an_array'));
+        $this->assertEquals('Queries must be an array', $validator->getDescription());
+
+        $this->assertFalse($validator->isValid(42));
+        $this->assertFalse($validator->isValid(null));
+    }
+
+    public function test_query_count_exceeds_length(): void
+    {
+        $validator = new Queries([new Limit()], length: 2);
+
+        $this->assertFalse($validator->isValid([
+            Query::limit(10),
+            Query::limit(20),
+            Query::limit(30),
+        ]));
+    }
+
+    public function test_aggregation_queries_add_aliases_to_order_validators(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'price',
+                'key' => 'price',
+                'type' => ColumnType::Double->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Aggregate(),
+            new Order($attributes),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::avg('price', 'avg_price'),
+            Query::orderAsc('avg_price'),
+        ]));
+    }
+
+    public function test_variance_and_stddev_method_type_mapping(): void
+    {
+        $validator = new Queries([new Aggregate()]);
+
+        $this->assertTrue($validator->isValid([Query::variance('col', 'var_col')]));
+        $this->assertTrue($validator->isValid([Query::stddev('col', 'std_col')]));
+    }
+
+    public function test_distinct_method_type_mapping(): void
+    {
+        $validator = new Queries([new Distinct()]);
+
+        $this->assertTrue($validator->isValid([Query::distinct()]));
+    }
+
+    public function test_group_by_method_type_mapping(): void
+    {
+        $validator = new Queries([new GroupBy()]);
+
+        $this->assertTrue($validator->isValid([Query::groupBy(['category'])]));
+    }
+
+    public function test_having_method_type_mapping(): void
+    {
+        $validator = new Queries([new Having()]);
+
+        $this->assertTrue($validator->isValid([Query::having([Query::greaterThan('count', 5)])]));
+    }
+
+    public function test_join_method_type_mapping(): void
+    {
+        $validator = new Queries([new Join()]);
+
+        $this->assertTrue($validator->isValid([Query::join('orders', 'user_id', 'id')]));
+    }
+
+    public function test_select_before_join_accepts_dotted_alias(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Select($attributes),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::select(['ord.amount']),
+            Query::join('orders', '$id', 'customer_uid', '=', 'ord'),
+        ]), $validator->getDescription());
+    }
+
+    public function test_filter_before_join_accepts_dotted_alias(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::equal('sec.amount', [777]),
+            Query::join('orders', '$id', 'customer_uid', '=', 'sec'),
+        ]), $validator->getDescription());
+    }
+
+    public function testNestedJoinAliasIsCollected(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Select($attributes),
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::select(['ord.amount']),
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customer_uid'),
+                Query::equal('ord.status', ['paid']),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function testNestedJoinOnFilterUnknownAliasIsInvalid(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertFalse($validator->isValid([
+            Query::leftJoin('orders', 'ord', [
+                Query::on('$id', 'customer_uid'),
+                Query::equal('missing.status', ['paid']),
+            ]),
+        ]));
+        $this->assertStringContainsString('Attribute not found in schema', $validator->getDescription());
+    }
+
+    public function test_order_before_join_accepts_dotted_alias(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Order($attributes),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::orderAsc('sec.amount'),
+            Query::join('orders', '$id', 'customer_uid', '=', 'sec'),
+        ]), $validator->getDescription());
+    }
+
+    public function test_unknown_join_alias_filter_is_rejected(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertFalse($validator->isValid([
+            Query::equal('other.amount', [777]),
+            Query::join('orders', '$id', 'customer_uid', '=', 'sec'),
+        ]));
+        $this->assertSame('Invalid query: Attribute not found in schema: other', $validator->getDescription());
+    }
+
+    public function test_nested_and_or_join_alias_is_accepted(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'rank',
+                'key' => 'rank',
+                'type' => ColumnType::Integer->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::join('meta', '$id', 'mainId', '=', 'meta'),
+            Query::and([
+                Query::equal('name', ['Main']),
+                Query::or([
+                    Query::equal('meta.score', [10]),
+                    Query::equal('rank', [2]),
+                ]),
+            ]),
+        ]), $validator->getDescription());
+    }
+
+    public function test_nested_and_or_unknown_join_alias_is_rejected(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'rank',
+                'key' => 'rank',
+                'type' => ColumnType::Integer->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertFalse($validator->isValid([
+            Query::join('meta', '$id', 'mainId', '=', 'meta'),
+            Query::and([
+                Query::equal('name', ['Main']),
+                Query::or([
+                    Query::equal('other.score', [10]),
+                    Query::equal('rank', [2]),
+                ]),
+            ]),
+        ]));
+        $this->assertSame('Invalid query: Attribute not found in schema: other', $validator->getDescription());
+    }
+
+    public function test_nested_and_or_multi_segment_join_column_is_rejected(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'rank',
+                'key' => 'rank',
+                'type' => ColumnType::Integer->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertFalse($validator->isValid([
+            Query::join('meta', '$id', 'mainId', '=', 'meta'),
+            Query::and([
+                Query::equal('name', ['Main']),
+                Query::or([
+                    Query::equal('meta.foo.bar', [10]),
+                    Query::equal('rank', [2]),
+                ]),
+            ]),
+        ]));
+        $this->assertSame('Invalid query: Attribute not found in schema: meta', $validator->getDescription());
+    }
+
+    public function test_join_alias_reset_between_isValid_calls(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'rank',
+                'key' => 'rank',
+                'type' => ColumnType::Integer->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+            new Join(),
+        ]);
+
+        $this->assertTrue($validator->isValid([
+            Query::join('meta', '$id', 'mainId', '=', 'meta'),
+            Query::equal('meta.score', [10]),
+        ]), $validator->getDescription());
+
+        $this->assertFalse($validator->isValid([
+            Query::join('peer', '$id', 'mainId', '=', 'peer'),
+            Query::equal('meta.score', [8686]),
+        ]));
+        $this->assertStringContainsString('Attribute not found', $validator->getDescription());
+        $this->assertStringContainsString('meta', $validator->getDescription());
+    }
+
+    public function test_nested_non_string_query_is_rejected(): void
+    {
+        $attributes = [
+            new Document([
+                '$id' => 'name',
+                'key' => 'name',
+                'type' => ColumnType::String->value,
+                'array' => false,
+            ]),
+        ];
+
+        $validator = new Queries([
+            new Filter($attributes, ColumnType::Integer->value),
+        ]);
+
+        $this->assertFalse($validator->isValid([
+            new Query(Method::And, '', [123, Query::equal('name', ['Main'])]),
+        ]));
+        $this->assertSame('Invalid query: nested query must be a string', $validator->getDescription());
+    }
+
+    public function test_is_array(): void
+    {
+        $validator = new Queries();
+
+        $this->assertTrue($validator->isArray());
+    }
+
+    public function test_get_type(): void
+    {
+        $validator = new Queries();
+
+        $this->assertEquals('object', $validator->getType());
+    }
 }
diff --git a/tests/unit/Validator/Query/CursorTest.php b/tests/unit/Validator/Query/CursorTest.php
index 7f18065498..2421cf40c5 100644
--- a/tests/unit/Validator/Query/CursorTest.php
+++ b/tests/unit/Validator/Query/CursorTest.php
@@ -5,18 +5,19 @@
 use PHPUnit\Framework\TestCase;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Cursor;
+use Utopia\Query\Method;
 
 class CursorTest extends TestCase
 {
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $validator = new Cursor();
 
-        $this->assertTrue($validator->isValid(new Query(Query::TYPE_CURSOR_AFTER, values: ['asdf'])));
-        $this->assertTrue($validator->isValid(new Query(Query::TYPE_CURSOR_BEFORE, values: ['asdf'])));
+        $this->assertTrue($validator->isValid(new Query(Method::CursorAfter, values: ['asdf'])));
+        $this->assertTrue($validator->isValid(new Query(Method::CursorBefore, values: ['asdf'])));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $validator = new Cursor();
 
@@ -29,4 +30,27 @@ public function testValueFailure(): void
         $this->assertFalse($validator->isValid(Query::orderAsc('attr')));
         $this->assertFalse($validator->isValid(Query::orderDesc('attr')));
     }
+
+    public function test_non_query_value_returns_false(): void
+    {
+        $validator = new Cursor();
+
+        $this->assertFalse($validator->isValid('some_string'));
+        $this->assertFalse($validator->isValid(42));
+        $this->assertFalse($validator->isValid(null));
+        $this->assertFalse($validator->isValid(['array']));
+    }
+
+    public function test_invalid_cursor_value_fails_uid_validation(): void
+    {
+        $validator = new Cursor();
+
+        $tooLong = str_repeat('x', 300);
+        $query = new Query(Method::CursorAfter, values: [$tooLong]);
+        $this->assertFalse($validator->isValid($query));
+        $this->assertStringContainsString('Invalid cursor', $validator->getDescription());
+
+        $emptyQuery = new Query(Method::CursorBefore, values: ['']);
+        $this->assertFalse($validator->isValid($emptyQuery));
+    }
 }
diff --git a/tests/unit/Validator/Query/FilterTest.php b/tests/unit/Validator/Query/FilterTest.php
index 21ba8f4046..d8b28cf666 100644
--- a/tests/unit/Validator/Query/FilterTest.php
+++ b/tests/unit/Validator/Query/FilterTest.php
@@ -3,83 +3,94 @@
 namespace Tests\Unit\Validator\Query;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
+use Utopia\Database\Exception;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Filter;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 
 class FilterTest extends TestCase
 {
-    protected Filter|null $validator = null;
+    protected Filter $validator;
 
     /**
-     * @throws \Utopia\Database\Exception
+     * @throws Exception
      */
-    public function setUp(): void
+    protected function setUp(): void
     {
         $attributes = [
             new Document([
                 '$id' => 'string',
                 'key' => 'string',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => false,
             ]),
             new Document([
                 '$id' => 'string_array',
                 'key' => 'string_array',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'array' => true,
             ]),
             new Document([
                 '$id' => 'integer_array',
                 'key' => 'integer_array',
-                'type' => Database::VAR_INTEGER,
+                'type' => ColumnType::Integer->value,
                 'array' => true,
             ]),
             new Document([
                 '$id' => 'integer',
                 'key' => 'integer',
-                'type' => Database::VAR_INTEGER,
+                'type' => ColumnType::Integer->value,
                 'array' => false,
             ]),
             new Document([
                 '$id' => 'bigint_unsigned',
                 'key' => 'bigint_unsigned',
-                'type' => Database::VAR_BIGINT,
+                'type' => ColumnType::BigInteger->value,
                 'array' => false,
                 'signed' => false,
             ]),
             new Document([
                 '$id' => 'bigint_signed',
                 'key' => 'bigint_signed',
-                'type' => Database::VAR_BIGINT,
+                'type' => ColumnType::BigInteger->value,
+                'array' => false,
+                'signed' => true,
+            ]),
+            new Document([
+                '$id' => 'bigint_legacy',
+                'key' => 'bigint_legacy',
+                'type' => 'bigint',
                 'array' => false,
                 'signed' => true,
             ]),
         ];
 
         $this->validator = new Filter(
-            $attributes,
-            Database::VAR_INTEGER
+            attributes: $attributes,
+            idAttributeType: ColumnType::Integer->value,
+            supportUnsignedBigInt: true,
         );
     }
 
-    public function testSuccess(): void
+    public function test_success(): void
     {
         $this->assertTrue($this->validator->isValid(Query::between('string', '1975-12-06', '2050-12-06')));
         $this->assertTrue($this->validator->isValid(Query::isNotNull('string')));
         $this->assertTrue($this->validator->isValid(Query::isNull('string')));
         $this->assertTrue($this->validator->isValid(Query::startsWith('string', 'super')));
         $this->assertTrue($this->validator->isValid(Query::endsWith('string', 'man')));
-        $this->assertTrue($this->validator->isValid(Query::contains('string_array', ['super'])));
-        $this->assertTrue($this->validator->isValid(Query::contains('integer_array', [100,10,-1])));
-        $this->assertTrue($this->validator->isValid(Query::contains('string_array', ["1","10","-1"])));
-        $this->assertTrue($this->validator->isValid(Query::contains('string', ['super'])));
+        $this->assertTrue($this->validator->isValid(Query::containsAny('string_array', ['super'])));
+        $this->assertTrue($this->validator->isValid(Query::containsAny('integer_array', [100, 10, -1])));
+        $this->assertTrue($this->validator->isValid(Query::containsAny('string_array', ['1', '10', '-1'])));
+        $this->assertTrue($this->validator->isValid(Query::containsString('string', ['super'])));
         $this->assertTrue($this->validator->isValid(Query::equal('bigint_unsigned', ['18446744073709551615'])));
         $this->assertTrue($this->validator->isValid(Query::equal('bigint_signed', ['-9223372036854775808'])));
+        $this->assertTrue($this->validator->isValid(Query::equal('bigint_legacy', ['9223372036854775807'])));
     }
 
-    public function testFailure(): void
+    public function test_failure(): void
     {
         $this->assertFalse($this->validator->isValid(Query::select(['attr'])));
         $this->assertEquals('Invalid query', $this->validator->getDescription());
@@ -97,14 +108,14 @@ public function testFailure(): void
         $this->assertFalse($this->validator->isValid(Query::equal('', ['v'])));
         $this->assertFalse($this->validator->isValid(Query::orderAsc('string')));
         $this->assertFalse($this->validator->isValid(Query::orderDesc('string')));
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_CURSOR_AFTER, values: ['asdf'])));
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_CURSOR_BEFORE, values: ['asdf'])));
-        $this->assertFalse($this->validator->isValid(Query::contains('integer', ['super'])));
-        $this->assertFalse($this->validator->isValid(Query::equal('integer_array', [100,-1])));
-        $this->assertFalse($this->validator->isValid(Query::contains('integer_array', [10.6])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::CursorAfter, values: ['asdf'])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::CursorBefore, values: ['asdf'])));
+        $this->assertFalse($this->validator->isValid(Query::containsString('integer', ['super'])));
+        $this->assertFalse($this->validator->isValid(Query::equal('integer_array', [100, -1])));
+        $this->assertFalse($this->validator->isValid(Query::containsAny('integer_array', [10.6])));
     }
 
-    public function testTypeMismatch(): void
+    public function test_type_mismatch(): void
     {
         $this->assertFalse($this->validator->isValid(Query::equal('string', [false])));
         $this->assertEquals('Query value is invalid for attribute "string"', $this->validator->getDescription());
@@ -113,16 +124,16 @@ public function testTypeMismatch(): void
         $this->assertEquals('Query value is invalid for attribute "string"', $this->validator->getDescription());
     }
 
-    public function testEmptyValues(): void
+    public function test_empty_values(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::contains('string', [])));
+        $this->assertFalse($this->validator->isValid(Query::containsString('string', [])));
         $this->assertEquals('Contains queries require at least one value.', $this->validator->getDescription());
 
         $this->assertFalse($this->validator->isValid(Query::equal('string', [])));
         $this->assertEquals('Equal queries require at least one value.', $this->validator->getDescription());
     }
 
-    public function testMaxValuesCount(): void
+    public function test_max_values_count(): void
     {
         $max = $this->validator->getMaxValuesCount();
         $values = [];
@@ -134,7 +145,7 @@ public function testMaxValuesCount(): void
         $this->assertEquals('Query on attribute has greater than '.$max.' values: integer', $this->validator->getDescription());
     }
 
-    public function testNotContains(): void
+    public function test_not_contains(): void
     {
         // Test valid notContains queries
         $this->assertTrue($this->validator->isValid(Query::notContains('string', ['unwanted'])));
@@ -146,7 +157,7 @@ public function testNotContains(): void
         $this->assertEquals('NotContains queries require at least one value.', $this->validator->getDescription());
     }
 
-    public function testNotSearch(): void
+    public function test_not_search(): void
     {
         // Test valid notSearch queries
         $this->assertTrue($this->validator->isValid(Query::notSearch('string', 'unwanted')));
@@ -156,11 +167,11 @@ public function testNotSearch(): void
         $this->assertEquals('Cannot query notSearch on attribute "string_array" because it is an array.', $this->validator->getDescription());
 
         // Test multiple values not allowed
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_NOT_SEARCH, 'string', ['word1', 'word2'])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::NotSearch, 'string', ['word1', 'word2'])));
         $this->assertEquals('NotSearch queries require exactly one value.', $this->validator->getDescription());
     }
 
-    public function testNotStartsWith(): void
+    public function test_not_starts_with(): void
     {
         // Test valid notStartsWith queries
         $this->assertTrue($this->validator->isValid(Query::notStartsWith('string', 'temp')));
@@ -170,11 +181,11 @@ public function testNotStartsWith(): void
         $this->assertEquals('Cannot query notStartsWith on attribute "string_array" because it is an array.', $this->validator->getDescription());
 
         // Test multiple values not allowed
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_NOT_STARTS_WITH, 'string', ['prefix1', 'prefix2'])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::NotStartsWith, 'string', ['prefix1', 'prefix2'])));
         $this->assertEquals('NotStartsWith queries require exactly one value.', $this->validator->getDescription());
     }
 
-    public function testNotEndsWith(): void
+    public function test_not_ends_with(): void
     {
         // Test valid notEndsWith queries
         $this->assertTrue($this->validator->isValid(Query::notEndsWith('string', '.tmp')));
@@ -184,11 +195,11 @@ public function testNotEndsWith(): void
         $this->assertEquals('Cannot query notEndsWith on attribute "string_array" because it is an array.', $this->validator->getDescription());
 
         // Test multiple values not allowed
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_NOT_ENDS_WITH, 'string', ['suffix1', 'suffix2'])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::NotEndsWith, 'string', ['suffix1', 'suffix2'])));
         $this->assertEquals('NotEndsWith queries require exactly one value.', $this->validator->getDescription());
     }
 
-    public function testNotBetween(): void
+    public function test_not_between(): void
     {
         // Test valid notBetween queries
         $this->assertTrue($this->validator->isValid(Query::notBetween('integer', 0, 50)));
@@ -198,10 +209,85 @@ public function testNotBetween(): void
         $this->assertEquals('Cannot query notBetween on attribute "integer_array" because it is an array.', $this->validator->getDescription());
 
         // Test wrong number of values
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_NOT_BETWEEN, 'integer', [10])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::NotBetween, 'integer', [10])));
         $this->assertEquals('NotBetween queries require exactly two values.', $this->validator->getDescription());
 
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_NOT_BETWEEN, 'integer', [10, 20, 30])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::NotBetween, 'integer', [10, 20, 30])));
         $this->assertEquals('NotBetween queries require exactly two values.', $this->validator->getDescription());
     }
+
+    public function test_dotted_join_alias_is_accepted_after_allow_join_aliases(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+
+        $this->assertTrue($this->validator->isValid(Query::equal('sec.amount', [777])));
+        $this->assertTrue($this->validator->isValid(Query::equal('sec.$id', ['abc'])));
+    }
+
+    public function test_unknown_join_alias_is_rejected(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+
+        $this->assertFalse($this->validator->isValid(Query::equal('other.amount', [777])));
+        $this->assertSame('Attribute not found in schema: other', $this->validator->getDescription());
+    }
+
+    public function test_unqualified_join_attribute_is_still_rejected(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+
+        $this->assertFalse($this->validator->isValid(Query::equal('amount', [777])));
+        $this->assertSame('Attribute not found in schema: amount', $this->validator->getDescription());
+    }
+
+    public function test_join_alias_is_rejected_after_reset(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+        $this->validator->resetJoinAliases();
+
+        $this->assertFalse($this->validator->isValid(Query::equal('sec.amount', [777])));
+        $this->assertSame('Attribute not found in schema: sec', $this->validator->getDescription());
+    }
+
+    public function test_nested_and_or_join_alias_is_accepted(): void
+    {
+        $this->validator->allowJoinAliases(['meta']);
+
+        $this->assertTrue($this->validator->isValid(Query::and([
+            Query::equal('string', ['Main']),
+            Query::or([
+                Query::equal('meta.score', [10]),
+                Query::equal('integer', [2]),
+            ]),
+        ])));
+    }
+
+    public function test_nested_and_or_unknown_join_alias_is_rejected(): void
+    {
+        $this->validator->allowJoinAliases(['meta']);
+
+        $this->assertFalse($this->validator->isValid(Query::and([
+            Query::equal('string', ['Main']),
+            Query::or([
+                Query::equal('other.score', [10]),
+                Query::equal('integer', [2]),
+            ]),
+        ])));
+        $this->assertSame('Attribute not found in schema: other', $this->validator->getDescription());
+    }
+
+    public function test_and_or_string_child_is_rejected(): void
+    {
+        $this->assertFalse($this->validator->isValid(new Query(Method::And, '', [
+            Query::equal('string', ['Main'])->toString(),
+            Query::equal('integer', [2])->toString(),
+        ])));
+        $this->assertSame('And queries can only contain filter queries', $this->validator->getDescription());
+
+        $this->assertFalse($this->validator->isValid(new Query(Method::Or, '', [
+            Query::equal('string', ['Main'])->toString(),
+            Query::equal('integer', [2])->toString(),
+        ])));
+        $this->assertSame('Or queries can only contain filter queries', $this->validator->getDescription());
+    }
 }
diff --git a/tests/unit/Validator/Query/FilterTypeBranchesTest.php b/tests/unit/Validator/Query/FilterTypeBranchesTest.php
new file mode 100644
index 0000000000..6c6b9f003d
--- /dev/null
+++ b/tests/unit/Validator/Query/FilterTypeBranchesTest.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace Tests\Unit\Validator\Query;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Query\Filter;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Covers the attribute types whose check reads the value itself, rather than
+ * only the column's declared type. These are the branches that cannot be
+ * hoisted out of the per-value loop, so they are the ones a reader has to trust
+ * stayed put.
+ */
+class FilterTypeBranchesTest extends TestCase
+{
+    protected Filter $validator;
+
+    protected function setUp(): void
+    {
+        $this->validator = new Filter(
+            attributes: [
+                new Document([
+                    '$id' => 'vector',
+                    'key' => 'vector',
+                    'type' => ColumnType::Vector->value,
+                    'array' => false,
+                    'size' => 3,
+                ]),
+                new Document([
+                    '$id' => 'point',
+                    'key' => 'point',
+                    'type' => ColumnType::Point->value,
+                    'array' => false,
+                ]),
+                new Document([
+                    '$id' => 'object',
+                    'key' => 'object',
+                    'type' => ColumnType::Object->value,
+                    'array' => false,
+                ]),
+                new Document([
+                    '$id' => 'text',
+                    'key' => 'text',
+                    'type' => ColumnType::String->value,
+                    'array' => false,
+                ]),
+            ],
+            idAttributeType: ColumnType::Integer->value,
+            supportUnsignedBigInt: true,
+        );
+    }
+
+    public function test_vector_requires_a_numeric_array_of_the_declared_size(): void
+    {
+        $this->assertTrue($this->validator->isValid(Query::equal('vector', [[1.0, 2.0, 3.0]])));
+
+        $this->assertFalse($this->validator->isValid(Query::equal('vector', ['not-an-array'])));
+        $this->assertSame('Vector query value must be an array', $this->validator->getDescription());
+
+        $this->assertFalse($this->validator->isValid(Query::equal('vector', [[1.0, 'two', 3.0]])));
+        $this->assertSame('Vector query value must contain only numeric values', $this->validator->getDescription());
+
+        $this->assertFalse($this->validator->isValid(Query::equal('vector', [[1.0, 2.0]])));
+        $this->assertSame('Vector query value must have 3 elements', $this->validator->getDescription());
+    }
+
+    public function test_spatial_requires_an_array_value(): void
+    {
+        $this->assertTrue($this->validator->isValid(Query::equal('point', [[1.0, 2.0]])));
+
+        $this->assertFalse($this->validator->isValid(Query::equal('point', ['1,2'])));
+        $this->assertSame('Spatial data must be an array', $this->validator->getDescription());
+    }
+
+    public function test_object_containment_rejects_mixed_key_arrays(): void
+    {
+        $this->assertTrue($this->validator->isValid(Query::equal('object', [['a' => 1]])));
+        $this->assertTrue($this->validator->isValid(Query::equal('object', ['plain-string'])), 'a scalar is not an object shape to check');
+
+        // A map and a list at once is the shape the check exists to refuse:
+        // it cannot be encoded as either a JSON object or a JSON array.
+        $this->assertFalse($this->validator->isValid(Query::equal('object', [['a' => 1, 0 => 'b']])));
+        $this->assertSame(
+            'Invalid object query structure for attribute "object"',
+            $this->validator->getDescription(),
+        );
+
+        $this->assertFalse($this->validator->isValid(Query::equal('object', [['nested' => ['x' => 1, 0 => 'y']]])), 'the check recurses');
+    }
+
+    public function test_a_dotted_object_path_is_validated_as_a_string(): void
+    {
+        $this->assertTrue($this->validator->isValid(Query::equal('object.nested', ['a-string'])));
+    }
+
+    public function test_every_value_is_checked_not_just_the_first(): void
+    {
+        $this->assertFalse($this->validator->isValid(Query::equal('vector', [[1.0, 2.0, 3.0], 'not-an-array'])));
+        $this->assertSame('Vector query value must be an array', $this->validator->getDescription());
+    }
+}
diff --git a/tests/unit/Validator/Query/GroupByTest.php b/tests/unit/Validator/Query/GroupByTest.php
new file mode 100644
index 0000000000..346bbe01d8
--- /dev/null
+++ b/tests/unit/Validator/Query/GroupByTest.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Tests\Unit\Validator\Query;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Query\GroupBy;
+use Utopia\Query\Method;
+
+class GroupByTest extends TestCase
+{
+    public function testValueSuccess(): void
+    {
+        $validator = new GroupBy();
+
+        $this->assertTrue($validator->isValid(Query::groupBy(['name'])));
+        $this->assertTrue($validator->isValid(Query::groupBy(['name', 'status'])));
+    }
+
+    public function testValueFailure(): void
+    {
+        $validator = new GroupBy();
+
+        $this->assertFalse($validator->isValid(Query::groupBy([])));
+        $this->assertSame('GroupBy requires at least one attribute', $validator->getDescription());
+
+        $this->assertFalse($validator->isValid(new Query(Method::GroupBy, '', [123])));
+        $this->assertSame('GroupBy attributes must be non-empty strings', $validator->getDescription());
+
+        $this->assertFalse($validator->isValid(new Query(Method::GroupBy, '', [''])));
+        $this->assertSame('GroupBy attributes must be non-empty strings', $validator->getDescription());
+    }
+}
diff --git a/tests/unit/Validator/Query/HavingTest.php b/tests/unit/Validator/Query/HavingTest.php
new file mode 100644
index 0000000000..f211cfb83d
--- /dev/null
+++ b/tests/unit/Validator/Query/HavingTest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\Unit\Validator\Query;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Query\Having;
+use Utopia\Query\Method;
+
+class HavingTest extends TestCase
+{
+    public function testValueSuccess(): void
+    {
+        $validator = new Having();
+
+        $this->assertTrue($validator->isValid(Query::having([Query::equal('count', [1])])));
+    }
+
+    public function testValueFailure(): void
+    {
+        $validator = new Having();
+
+        $this->assertFalse($validator->isValid(Query::having([])));
+        $this->assertSame('Having requires at least one condition', $validator->getDescription());
+
+        $this->assertFalse($validator->isValid(new Query(Method::Having, '', ['count > 1'])));
+        $this->assertSame('Having conditions must be Query instances', $validator->getDescription());
+    }
+}
diff --git a/tests/unit/Validator/Query/LimitTest.php b/tests/unit/Validator/Query/LimitTest.php
index f0c598d3d8..be287ac71a 100644
--- a/tests/unit/Validator/Query/LimitTest.php
+++ b/tests/unit/Validator/Query/LimitTest.php
@@ -8,7 +8,7 @@
 
 class LimitTest extends TestCase
 {
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $validator = new Limit(100);
 
@@ -16,7 +16,7 @@ public function testValueSuccess(): void
         $this->assertTrue($validator->isValid(Query::limit(100)));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $validator = new Limit(100);
 
diff --git a/tests/unit/Validator/Query/OffsetTest.php b/tests/unit/Validator/Query/OffsetTest.php
index 9484083465..5071f0130a 100644
--- a/tests/unit/Validator/Query/OffsetTest.php
+++ b/tests/unit/Validator/Query/OffsetTest.php
@@ -5,10 +5,11 @@
 use PHPUnit\Framework\TestCase;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Offset;
+use Utopia\Query\Method;
 
 class OffsetTest extends TestCase
 {
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $validator = new Offset(5000);
 
@@ -17,13 +18,15 @@ public function testValueSuccess(): void
         $this->assertTrue($validator->isValid(Query::offset(5000)));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $validator = new Offset(5000);
 
         $this->assertFalse($validator->isValid(Query::offset(-1)));
         $this->assertEquals('Invalid offset: Value must be a valid range between 0 and 5,000', $validator->getDescription());
         $this->assertFalse($validator->isValid(Query::offset(5001)));
+        $this->assertFalse($validator->isValid(new Query(Method::Offset, '', ['foo'])));
+        $this->assertSame('Invalid offset: Value must be a valid number', $validator->getDescription());
         $this->assertFalse($validator->isValid(Query::equal('attr', ['v'])));
         $this->assertFalse($validator->isValid(Query::orderAsc('attr')));
         $this->assertFalse($validator->isValid(Query::orderDesc('attr')));
diff --git a/tests/unit/Validator/Query/OrderTest.php b/tests/unit/Validator/Query/OrderTest.php
index b84d896d16..e697c6c478 100644
--- a/tests/unit/Validator/Query/OrderTest.php
+++ b/tests/unit/Validator/Query/OrderTest.php
@@ -3,41 +3,40 @@
 namespace Tests\Unit\Validator\Query;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Query\Base;
 use Utopia\Database\Validator\Query\Order;
+use Utopia\Query\Schema\ColumnType;
 
 class OrderTest extends TestCase
 {
-    protected Base|null $validator = null;
+    protected Order $validator;
 
     /**
      * @throws Exception
      */
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->validator = new Order(
             attributes: [
                 new Document([
                     '$id' => 'attr',
                     'key' => 'attr',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'array' => false,
                 ]),
                 new Document([
                     '$id' => '$sequence',
                     'key' => '$sequence',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'array' => false,
                 ]),
             ],
         );
     }
 
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $this->assertTrue($this->validator->isValid(Query::orderAsc('attr')));
         $this->assertTrue($this->validator->isValid(Query::orderAsc()));
@@ -45,7 +44,7 @@ public function testValueSuccess(): void
         $this->assertTrue($this->validator->isValid(Query::orderDesc()));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $this->assertFalse($this->validator->isValid(Query::limit(-1)));
         $this->assertEquals('Invalid query', $this->validator->getDescription());
@@ -58,4 +57,73 @@ public function testValueFailure(): void
         $this->assertFalse($this->validator->isValid(Query::orderDesc('dne')));
         $this->assertFalse($this->validator->isValid(Query::orderAsc('dne')));
     }
+
+    public function test_dotted_attribute_with_relationship_base(): void
+    {
+        $validator = new Order(
+            attributes: [
+                new Document([
+                    '$id' => 'profile',
+                    'key' => 'profile',
+                    'type' => ColumnType::Relationship->value,
+                    'array' => false,
+                ]),
+            ],
+        );
+
+        $this->assertFalse($validator->isValid(Query::orderAsc('profile.name')));
+        $this->assertEquals('Cannot order by nested attribute: profile', $validator->getDescription());
+    }
+
+    public function test_dotted_attribute_not_in_schema(): void
+    {
+        $this->assertFalse($this->validator->isValid(Query::orderAsc('unknown.field')));
+        $this->assertEquals('Attribute not found in schema: unknown', $this->validator->getDescription());
+    }
+
+    public function test_non_query_input_returns_false(): void
+    {
+        $this->assertFalse($this->validator->isValid('not_a_query'));
+        $this->assertFalse($this->validator->isValid(42));
+        $this->assertFalse($this->validator->isValid(null));
+    }
+
+    public function test_order_random_is_valid(): void
+    {
+        $query = Query::orderRandom();
+        $this->assertTrue($this->validator->isValid($query));
+    }
+
+    public function test_add_aggregation_aliases(): void
+    {
+        $this->validator->addAggregationAliases(['total_count', 'avg_price']);
+
+        $this->assertTrue($this->validator->isValid(Query::orderAsc('total_count')));
+        $this->assertTrue($this->validator->isValid(Query::orderDesc('avg_price')));
+    }
+
+    public function testDottedJoinAliasIsAcceptedAfterAllowJoinAliases(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+
+        $this->assertTrue($this->validator->isValid(Query::orderAsc('sec.amount')));
+        $this->assertTrue($this->validator->isValid(Query::orderDesc('sec.$id')));
+    }
+
+    public function testUnknownJoinAliasIsRejected(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+
+        $this->assertFalse($this->validator->isValid(Query::orderAsc('other.amount')));
+        $this->assertSame('Attribute not found in schema: other', $this->validator->getDescription());
+    }
+
+    public function testJoinAliasIsRejectedAfterReset(): void
+    {
+        $this->validator->allowJoinAliases(['sec']);
+        $this->validator->resetJoinAliases();
+
+        $this->assertFalse($this->validator->isValid(Query::orderAsc('sec.amount')));
+        $this->assertSame('Attribute not found in schema: sec', $this->validator->getDescription());
+    }
 }
diff --git a/tests/unit/Validator/Query/SelectTest.php b/tests/unit/Validator/Query/SelectTest.php
index 86b8d2495c..438925c0e2 100644
--- a/tests/unit/Validator/Query/SelectTest.php
+++ b/tests/unit/Validator/Query/SelectTest.php
@@ -2,48 +2,49 @@
 
 namespace Tests\Unit\Validator\Query;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Query\Base;
 use Utopia\Database\Validator\Query\Select;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 
 class SelectTest extends TestCase
 {
-    protected Base|null $validator = null;
+    protected Select $validator;
 
     /**
      * @throws Exception
      */
-    public function setUp(): void
+    protected function setUp(): void
     {
         $this->validator = new Select(
             attributes: [
                 new Document([
                     '$id' => 'attr',
                     'key' => 'attr',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'array' => false,
                 ]),
                 new Document([
                     '$id' => 'artist',
                     'key' => 'artist',
-                    'type' => Database::VAR_RELATIONSHIP,
+                    'type' => ColumnType::Relationship->value,
                     'array' => false,
                 ]),
             ],
         );
     }
 
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $this->assertTrue($this->validator->isValid(Query::select(['*', 'attr'])));
         $this->assertTrue($this->validator->isValid(Query::select(['artist.name'])));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $this->assertFalse($this->validator->isValid(Query::limit(1)));
         $this->assertEquals('Invalid query', $this->validator->getDescription());
@@ -57,12 +58,11 @@ public function testValueFailure(): void
      * a malformed value that way.
      *
      * @param array<mixed> $values
-     *
-     * @dataProvider nonStringSelections
      */
+    #[DataProvider('nonStringSelections')]
     public function testANonStringSelectionIsRefusedByType(array $values, string $expected): void
     {
-        $this->assertFalse($this->validator->isValid(Query::select($values)));
+        $this->assertFalse($this->validator->isValid(new Query(Method::Select, values: $values)));
         $this->assertSame($expected, $this->validator->getDescription());
     }
 
@@ -105,4 +105,20 @@ public function testTheLegitimateFlatFormStillPasses(): void
         $this->assertTrue($this->validator->isValid(Query::select(['$id', '$createdAt'])));
         $this->assertTrue($this->validator->isValid(Query::select(['artist.name'])));
     }
+
+    public function testDottedJoinAliasIsAcceptedAfterAllowJoinAliases(): void
+    {
+        $this->validator->allowJoinAliases(['ord']);
+
+        $this->assertTrue($this->validator->isValid(Query::select(['ord.amount'])));
+        $this->assertTrue($this->validator->isValid(Query::select(['ord.$id'])));
+    }
+
+    public function testUnqualifiedAmountIsStillRejected(): void
+    {
+        $this->validator->allowJoinAliases(['ord']);
+
+        $this->assertFalse($this->validator->isValid(Query::select(['amount'])));
+        $this->assertSame('Attribute not found in schema: amount', $this->validator->getDescription());
+    }
 }
diff --git a/tests/unit/Validator/QueryTest.php b/tests/unit/Validator/QueryTest.php
index 8433f47f21..1364328508 100644
--- a/tests/unit/Validator/QueryTest.php
+++ b/tests/unit/Validator/QueryTest.php
@@ -4,10 +4,11 @@
 
 use Exception;
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Queries\Documents;
+use Utopia\Query\Method;
+use Utopia\Query\Schema\ColumnType;
 
 class QueryTest extends TestCase
 {
@@ -19,13 +20,13 @@ class QueryTest extends TestCase
     /**
      * @throws Exception
      */
-    public function setUp(): void
+    protected function setUp(): void
     {
         $attributes = [
             [
                 '$id' => 'title',
                 'key' => 'title',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 256,
                 'required' => true,
                 'signed' => true,
@@ -35,7 +36,7 @@ public function setUp(): void
             [
                 '$id' => 'description',
                 'key' => 'description',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 1000000,
                 'required' => true,
                 'signed' => true,
@@ -45,7 +46,7 @@ public function setUp(): void
             [
                 '$id' => 'rating',
                 'key' => 'rating',
-                'type' => Database::VAR_INTEGER,
+                'type' => ColumnType::Integer->value,
                 'size' => 5,
                 'required' => true,
                 'signed' => true,
@@ -55,7 +56,7 @@ public function setUp(): void
             [
                 '$id' => 'price',
                 'key' => 'price',
-                'type' => Database::VAR_FLOAT,
+                'type' => ColumnType::Double->value,
                 'size' => 5,
                 'required' => true,
                 'signed' => true,
@@ -65,7 +66,7 @@ public function setUp(): void
             [
                 '$id' => 'published',
                 'key' => 'published',
-                'type' => Database::VAR_BOOLEAN,
+                'type' => ColumnType::Boolean->value,
                 'size' => 5,
                 'required' => true,
                 'signed' => true,
@@ -75,7 +76,7 @@ public function setUp(): void
             [
                 '$id' => 'tags',
                 'key' => 'tags',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 55,
                 'required' => true,
                 'signed' => true,
@@ -85,7 +86,7 @@ public function setUp(): void
             [
                 '$id' => 'birthDay',
                 'key' => 'birthDay',
-                'type' => Database::VAR_DATETIME,
+                'type' => ColumnType::Datetime->value,
                 'size' => 0,
                 'required' => false,
                 'signed' => false,
@@ -99,16 +100,16 @@ public function setUp(): void
         }
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws Exception
      */
-    public function testQuery(): void
+    public function test_query(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $this->assertEquals(true, $validator->isValid([Query::equal('$id', ['Iron Man', 'Ant Man'])]));
         $this->assertEquals(true, $validator->isValid([Query::equal('$id', ['Iron Man'])]));
@@ -136,9 +137,9 @@ public function testQuery(): void
     /**
      * @throws Exception
      */
-    public function testAttributeNotFound(): void
+    public function test_attribute_not_found(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::equal('name', ['Iron Man'])]);
         $this->assertEquals(false, $response);
@@ -152,9 +153,9 @@ public function testAttributeNotFound(): void
     /**
      * @throws Exception
      */
-    public function testAttributeWrongType(): void
+    public function test_attribute_wrong_type(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::equal('title', [1776])]);
         $this->assertEquals(false, $response);
@@ -164,9 +165,9 @@ public function testAttributeWrongType(): void
     /**
      * @throws Exception
      */
-    public function testQueryDate(): void
+    public function test_query_date(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::greaterThan('birthDay', '1960-01-01 10:10:10')]);
         $this->assertEquals(true, $response);
@@ -175,9 +176,9 @@ public function testQueryDate(): void
     /**
      * @throws Exception
      */
-    public function testQueryLimit(): void
+    public function test_query_limit(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::limit(25)]);
         $this->assertEquals(true, $response);
@@ -189,9 +190,9 @@ public function testQueryLimit(): void
     /**
      * @throws Exception
      */
-    public function testQueryOffset(): void
+    public function test_query_offset(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::offset(25)]);
         $this->assertEquals(true, $response);
@@ -203,9 +204,9 @@ public function testQueryOffset(): void
     /**
      * @throws Exception
      */
-    public function testQueryOrder(): void
+    public function test_query_order(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::orderAsc('title')]);
         $this->assertEquals(true, $response);
@@ -223,9 +224,9 @@ public function testQueryOrder(): void
     /**
      * @throws Exception
      */
-    public function testQueryCursor(): void
+    public function test_query_cursor(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::cursorAfter(new Document(['$id' => 'asdf']))]);
         $this->assertEquals(true, $response);
@@ -234,7 +235,7 @@ public function testQueryCursor(): void
     /**
      * @throws Exception
      */
-    public function testQueryGetByType(): void
+    public function test_query_get_by_type(): void
     {
         $queries = [
             Query::equal('key', ['value']),
@@ -242,29 +243,26 @@ public function testQueryGetByType(): void
             Query::cursorAfter(new Document([])),
         ];
 
-        $queries1 = Query::getByType($queries, [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]);
+        $queries1 = Query::getByType($queries, [Method::CursorAfter, Method::CursorBefore]);
 
         $this->assertCount(2, $queries1);
         foreach ($queries1 as $query) {
-            $this->assertEquals(true, in_array($query->getMethod(), [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]));
+            $this->assertEquals(true, in_array($query->getMethod(), [Method::CursorAfter, Method::CursorBefore]));
         }
 
         $cursor = reset($queries1);
-
-        $this->assertInstanceOf(Query::class, $cursor);
-
         $cursor->setValue(new Document(['$id' => 'hello1']));
 
         $query1 = $queries[1];
 
-        $this->assertEquals(Query::TYPE_CURSOR_BEFORE, $query1->getMethod());
+        $this->assertEquals(Method::CursorBefore, $query1->getMethod());
         $this->assertInstanceOf(Document::class, $query1->getValue());
         $this->assertTrue($query1->getValue()->isEmpty()); // Cursor Document is not updated
 
         /**
          * Using reference $queries2 => $queries
          */
-        $queries2 = Query::getByType($queries, [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE], false);
+        $queries2 = Query::getByType($queries, [Method::CursorAfter, Method::CursorBefore], false);
 
         $cursor = reset($queries2);
         $this->assertInstanceOf(Query::class, $cursor);
@@ -274,7 +272,7 @@ public function testQueryGetByType(): void
         $query2 = $queries[1];
 
         $this->assertCount(2, $queries2);
-        $this->assertEquals(Query::TYPE_CURSOR_BEFORE, $query2->getMethod());
+        $this->assertEquals(Method::CursorBefore, $query2->getMethod());
         $this->assertInstanceOf(Document::class, $query2->getValue());
         $this->assertEquals('hello1', $query2->getValue()->getId()); // Cursor Document is updated
 
@@ -297,7 +295,7 @@ public function testQueryGetByType(): void
         $query3 = $queries[1];
 
         $this->assertCount(2, $queries3);
-        $this->assertEquals(Query::TYPE_CURSOR_BEFORE, $query3->getMethod());
+        $this->assertEquals(Method::CursorBefore, $query3->getMethod());
         $this->assertInstanceOf(Document::class, $query3->getValue());
         $this->assertEquals('hello3', $query3->getValue()->getId()); // Cursor Document is updated
     }
@@ -305,9 +303,9 @@ public function testQueryGetByType(): void
     /**
      * @throws Exception
      */
-    public function testQueryEmpty(): void
+    public function test_query_empty(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $response = $validator->isValid([Query::equal('title', [''])]);
         $this->assertEquals(true, $response);
@@ -334,9 +332,9 @@ public function testQueryEmpty(): void
     /**
      * @throws Exception
      */
-    public function testOrQuery(): void
+    public function test_or_query(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new Documents($this->attributes, [], ColumnType::Integer->value);
 
         $this->assertFalse($validator->isValid(
             [Query::or(
@@ -351,7 +349,7 @@ public function testOrQuery(): void
                 Query::or(
                     [
                         Query::equal('price', [0]),
-                        Query::equal('not_found', [''])
+                        Query::equal('not_found', ['']),
                     ]
                 )]
         ));
@@ -364,7 +362,7 @@ public function testOrQuery(): void
                 Query::or(
                     [
                         Query::select(['price']),
-                        Query::limit(1)
+                        Query::limit(1),
                     ]
                 )]
         ));
diff --git a/tests/unit/Validator/RolesTest.php b/tests/unit/Validator/RolesTest.php
index a0ac63ed75..90cc4e06d1 100644
--- a/tests/unit/Validator/RolesTest.php
+++ b/tests/unit/Validator/RolesTest.php
@@ -9,18 +9,18 @@
 
 class RolesTest extends TestCase
 {
-    public function setUp(): void
+    protected function setUp(): void
     {
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
     /**
      * @throws \Exception
      */
-    public function testValidRole(): void
+    public function test_valid_role(): void
     {
         $object = new Roles();
         $this->assertTrue($object->isValid([Role::users()->toString()]));
@@ -32,56 +32,56 @@ public function testValidRole(): void
         $this->assertTrue($object->isValid([Role::label('vip')->toString()]));
     }
 
-    public function testNotAnArray(): void
+    public function test_not_an_array(): void
     {
         $object = new Roles();
         $this->assertFalse($object->isValid('not an array'));
         $this->assertEquals('Roles must be an array of strings.', $object->getDescription());
     }
 
-    public function testExceedLength(): void
+    public function test_exceed_length(): void
     {
         $object = new Roles(2);
         $this->assertFalse($object->isValid([
             Role::users()->toString(),
             Role::users()->toString(),
-            Role::users()->toString()
+            Role::users()->toString(),
         ]));
         $this->assertEquals('You can only provide up to 2 roles.', $object->getDescription());
     }
 
-    public function testNotAllStrings(): void
+    public function test_not_all_strings(): void
     {
         $object = new Roles();
         $this->assertFalse($object->isValid([
             Role::users()->toString(),
-            123
+            123,
         ]));
         $this->assertEquals('Every role must be of type string.', $object->getDescription());
     }
 
-    public function testObsoleteWildcardRole(): void
+    public function test_obsolete_wildcard_role(): void
     {
         $object = new Roles();
         $this->assertFalse($object->isValid(['*']));
         $this->assertEquals('Wildcard role "*" has been replaced. Use "any" instead.', $object->getDescription());
     }
 
-    public function testObsoleteRolePrefix(): void
+    public function test_obsolete_role_prefix(): void
     {
         $object = new Roles();
         $this->assertFalse($object->isValid(['read("role:123")']));
         $this->assertEquals('Roles using the "role:" prefix have been removed. Use "users", "guests", or "any" instead.', $object->getDescription());
     }
 
-    public function testDisallowedRoles(): void
+    public function test_disallowed_roles(): void
     {
         $object = new Roles(allowed: [Roles::ROLE_USERS]);
         $this->assertFalse($object->isValid([Role::any()->toString()]));
         $this->assertEquals('Role "any" is not allowed. Must be one of: users.', $object->getDescription());
     }
 
-    public function testLabels(): void
+    public function test_labels(): void
     {
         $object = new Roles();
         $this->assertTrue($object->isValid(['label:123']));
diff --git a/tests/unit/Validator/SpatialTest.php b/tests/unit/Validator/SpatialTest.php
index e8df4d3d10..dc954e0523 100644
--- a/tests/unit/Validator/SpatialTest.php
+++ b/tests/unit/Validator/SpatialTest.php
@@ -3,14 +3,14 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Validator\Spatial;
+use Utopia\Query\Schema\ColumnType;
 
 class SpatialTest extends TestCase
 {
-    public function testValidPoint(): void
+    public function test_valid_point(): void
     {
-        $validator = new Spatial(Database::VAR_POINT);
+        $validator = new Spatial(ColumnType::Point->value);
 
         $this->assertTrue($validator->isValid([10, 20]));
         $this->assertTrue($validator->isValid([0, 0]));
@@ -22,9 +22,9 @@ public function testValidPoint(): void
         $this->assertFalse($validator->isValid([[10, 20]])); // Nested array
     }
 
-    public function testValidLineString(): void
+    public function test_valid_line_string(): void
     {
-        $validator = new Spatial(Database::VAR_LINESTRING);
+        $validator = new Spatial(ColumnType::Linestring->value);
 
         $this->assertTrue($validator->isValid([[0, 0], [1, 1]]));
 
@@ -36,9 +36,9 @@ public function testValidLineString(): void
         $this->assertFalse($validator->isValid([[10, 10], ['x', 'y']])); // Non-numeric
     }
 
-    public function testValidPolygon(): void
+    public function test_valid_polygon(): void
     {
-        $validator = new Spatial(Database::VAR_POLYGON);
+        $validator = new Spatial(ColumnType::Polygon->value);
 
         // Single ring polygon (closed)
         $this->assertTrue($validator->isValid([
@@ -46,33 +46,33 @@ public function testValidPolygon(): void
             [0, 1],
             [1, 1],
             [1, 0],
-            [0, 0]
+            [0, 0],
         ]));
 
         // Multi-ring polygon
         $this->assertTrue($validator->isValid([
             [   // Outer ring
-                [0, 0], [0, 4], [4, 4], [4, 0], [0, 0]
+                [0, 0], [0, 4], [4, 4], [4, 0], [0, 0],
             ],
             [   // Hole
-                [1, 1], [1, 2], [2, 2], [2, 1], [1, 1]
-            ]
+                [1, 1], [1, 2], [2, 2], [2, 1], [1, 1],
+            ],
         ]));
 
         // Invalid polygons
         $this->assertFalse($validator->isValid([])); // Empty
         $this->assertFalse($validator->isValid([
-            [0, 0], [1, 1], [2, 2] // Not closed, less than 4 points
+            [0, 0], [1, 1], [2, 2], // Not closed, less than 4 points
         ]));
         $this->assertFalse($validator->isValid([
-            [[0, 0], [1, 1], [1, 0]] // Not closed
+            [[0, 0], [1, 1], [1, 0]], // Not closed
         ]));
         $this->assertFalse($validator->isValid([
-            [[0, 0], [1, 1], [1, 'a'], [0, 0]] // Non-numeric
+            [[0, 0], [1, 1], [1, 'a'], [0, 0]], // Non-numeric
         ]));
     }
 
-    public function testWKTStrings(): void
+    public function test_wkt_strings(): void
     {
         $this->assertTrue(Spatial::isWKTString('POINT(1 2)'));
         $this->assertTrue(Spatial::isWKTString('LINESTRING(0 0,1 1)'));
@@ -82,30 +82,30 @@ public function testWKTStrings(): void
         $this->assertFalse(Spatial::isWKTString('POINT1(1 2)'));
     }
 
-    public function testInvalidCoordinate(): void
+    public function test_invalid_coordinate(): void
     {
         // Point with invalid longitude
-        $validator = new Spatial(Database::VAR_POINT);
+        $validator = new Spatial(ColumnType::Point->value);
         $this->assertFalse($validator->isValid([200, 10])); // longitude > 180
         $this->assertStringContainsString('Longitude', $validator->getDescription());
 
         // Point with invalid latitude
-        $validator = new Spatial(Database::VAR_POINT);
+        $validator = new Spatial(ColumnType::Point->value);
         $this->assertFalse($validator->isValid([10, -100])); // latitude < -90
         $this->assertStringContainsString('Latitude', $validator->getDescription());
 
         // LineString with invalid coordinates
-        $validator = new Spatial(Database::VAR_LINESTRING);
+        $validator = new Spatial(ColumnType::Linestring->value);
         $this->assertFalse($validator->isValid([
             [0, 0],
-            [181, 45] // invalid longitude
+            [181, 45], // invalid longitude
         ]));
         $this->assertStringContainsString('Invalid coordinates', $validator->getDescription());
 
         // Polygon with invalid coordinates
-        $validator = new Spatial(Database::VAR_POLYGON);
+        $validator = new Spatial(ColumnType::Polygon->value);
         $this->assertFalse($validator->isValid([
-            [[0, 0], [1, 1], [190, 5], [0, 0]] // invalid longitude in ring
+            [[0, 0], [1, 1], [190, 5], [0, 0]], // invalid longitude in ring
         ]));
         $this->assertStringContainsString('Invalid coordinates', $validator->getDescription());
     }
diff --git a/tests/unit/Validator/StructureTest.php b/tests/unit/Validator/StructureTest.php
index 71c90577cb..bc40840350 100644
--- a/tests/unit/Validator/StructureTest.php
+++ b/tests/unit/Validator/StructureTest.php
@@ -10,6 +10,7 @@
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Operator;
 use Utopia\Database\Validator\Structure;
+use Utopia\Query\Schema\ColumnType;
 
 class StructureTest extends TestCase
 {
@@ -23,7 +24,7 @@ class StructureTest extends TestCase
         'attributes' => [
             [
                 '$id' => 'title',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'format' => '',
                 'size' => 256,
                 'required' => true,
@@ -33,7 +34,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'description',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'format' => '',
                 'size' => 1000000,
                 'required' => false,
@@ -43,7 +44,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'rating',
-                'type' => Database::VAR_INTEGER,
+                'type' => ColumnType::Integer->value,
                 'format' => '',
                 'size' => 5,
                 'required' => true,
@@ -53,7 +54,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'reviews',
-                'type' => Database::VAR_INTEGER,
+                'type' => ColumnType::Integer->value,
                 'format' => '',
                 'size' => 5,
                 'required' => false,
@@ -63,7 +64,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'price',
-                'type' => Database::VAR_FLOAT,
+                'type' => ColumnType::Double->value,
                 'format' => '',
                 'size' => 5,
                 'required' => true,
@@ -73,7 +74,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'published',
-                'type' => Database::VAR_BOOLEAN,
+                'type' => ColumnType::Boolean->value,
                 'format' => '',
                 'size' => 5,
                 'required' => true,
@@ -83,7 +84,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'tags',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'format' => '',
                 'size' => 55,
                 'required' => false,
@@ -93,7 +94,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'id',
-                'type' => Database::VAR_ID,
+                'type' => ColumnType::Id->value,
                 'format' => '',
                 'size' => 0,
                 'required' => false,
@@ -103,7 +104,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'varchar_field',
-                'type' => Database::VAR_VARCHAR,
+                'type' => ColumnType::Varchar->value,
                 'format' => '',
                 'size' => 255,
                 'required' => false,
@@ -113,7 +114,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'text_field',
-                'type' => Database::VAR_TEXT,
+                'type' => ColumnType::Text->value,
                 'format' => '',
                 'size' => 65535,
                 'required' => false,
@@ -123,7 +124,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'mediumtext_field',
-                'type' => Database::VAR_MEDIUMTEXT,
+                'type' => ColumnType::MediumText->value,
                 'format' => '',
                 'size' => 16777215,
                 'required' => false,
@@ -133,7 +134,7 @@ class StructureTest extends TestCase
             ],
             [
                 '$id' => 'longtext_field',
-                'type' => Database::VAR_LONGTEXT,
+                'type' => ColumnType::LongText->value,
                 'format' => '',
                 'size' => 4294967295,
                 'required' => false,
@@ -145,18 +146,23 @@ class StructureTest extends TestCase
         'indexes' => [],
     ];
 
-    public function setUp(): void
+    protected function setUp(): void
     {
-        Structure::addFormat('email', function ($attribute) {
-            $size = $attribute['size'] ?? 0;
+        Structure::addFormat('email', function (mixed $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $sizeRaw = $attribute['size'] ?? 0;
+            $size = is_numeric($sizeRaw) ? (int) $sizeRaw : 0;
+
             return new Format($size);
-        }, Database::VAR_STRING);
+        }, ColumnType::String);
 
         // Cannot encode format when defining constants
         // So add feedback attribute on startup
-        $this->collection['attributes'][] = [
+        /** @var array<int, array<string, mixed>> $attrs */
+        $attrs = $this->collection['attributes'];
+        $attrs[] = [
             '$id' => ID::custom('feedback'),
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'format' => 'email',
             'size' => 55,
             'required' => true,
@@ -164,17 +170,18 @@ public function setUp(): void
             'array' => false,
             'filters' => [],
         ];
+        $this->collection['attributes'] = $attrs;
     }
 
-    public function tearDown(): void
+    protected function tearDown(): void
     {
     }
 
-    public function testDocumentInstance(): void
+    public function test_document_instance(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid('string'));
@@ -185,11 +192,11 @@ public function testDocumentInstance(): void
         $this->assertEquals('Invalid document structure: Value must be an instance of Document', $validator->getDescription());
     }
 
-    public function testCollectionAttribute(): void
+    public function test_collection_attribute(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document()));
@@ -197,11 +204,11 @@ public function testCollectionAttribute(): void
         $this->assertEquals('Invalid document structure: Missing collection attribute $collection', $validator->getDescription());
     }
 
-    public function testCollection(): void
+    public function test_collection(): void
     {
         $validator = new Structure(
             new Document(),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -214,17 +221,17 @@ public function testCollection(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Collection not found', $validator->getDescription());
     }
 
-    public function testRequiredKeys(): void
+    public function test_required_keys(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -236,17 +243,17 @@ public function testRequiredKeys(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Missing required attribute "title"', $validator->getDescription());
     }
 
-    public function testNullValues(): void
+    public function test_null_values(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -273,15 +280,15 @@ public function testNullValues(): void
             'tags' => ['dog', null, 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
     }
 
-    public function testUnknownKeys(): void
+    public function test_unknown_keys(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -295,17 +302,17 @@ public function testUnknownKeys(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Unknown attribute: "titlex"', $validator->getDescription());
     }
 
-    public function testIntegerAsString(): void
+    public function test_integer_as_string(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -318,17 +325,17 @@ public function testIntegerAsString(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "rating" has invalid type. Value must be a valid signed 32-bit integer between -2,147,483,648 and 2,147,483,647', $validator->getDescription());
     }
 
-    public function testValidDocument(): void
+    public function test_valid_document(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -341,15 +348,15 @@ public function testValidDocument(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
     }
 
-    public function testStringValidation(): void
+    public function test_string_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -362,127 +369,17 @@ public function testStringValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "title" has invalid type. Value must be a valid string and no longer than 256 chars', $validator->getDescription());
     }
 
-    public function testTextByteSafeValidationTooBig(): void
-    {
-        // A legacy `text` attribute whose declared size (1MB) exceeds the real
-        // 65,535-byte capacity of a TEXT column. Such attributes exist in older
-        // databases created before VAR_TEXT was capped, so the limit must come
-        // from the column type, not from the (untrustworthy) declared size.
-        $collection = new Document([
-            '$id' => ID::custom('posts'),
-            '$collection' => Database::METADATA,
-            'name' => 'posts',
-            'attributes' => [
-                [
-                    '$id' => 'text',
-                    'type' => Database::VAR_TEXT,
-                    'format' => '',
-                    'size' => 1048576,
-                    'required' => false,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ],
-            ],
-            'indexes' => [],
-        ]);
-
-        $validator = new Structure($collection, Database::VAR_INTEGER);
-
-        $base = [
-            '$collection' => ID::custom('posts'),
-            '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
-        ];
-
-        // A TEXT column is limited to 65,535 bytes. Validation measures the
-        // value's actual byte length, so a value over that capacity is rejected
-        // even though the declared $size (1MB) would allow the character count.
-        $tooBig = \str_repeat('a', 65536);
-        $this->assertEquals(false, $validator->isValid(new Document($base + ['text' => $tooBig])));
-        $this->assertEquals('Invalid document structure: Attribute "text" has invalid type. Value must be a valid string no longer than 65535 bytes', $validator->getDescription());
-    }
-
-    public function testTextByteSafeValidationMultibyte(): void
-    {
-        $collection = new Document([
-            '$id' => ID::custom('posts'),
-            '$collection' => Database::METADATA,
-            'name' => 'posts',
-            'attributes' => [
-                [
-                    '$id' => 'text',
-                    'type' => Database::VAR_TEXT,
-                    'format' => '',
-                    'size' => 1048576,
-                    'required' => false,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ],
-            ],
-            'indexes' => [],
-        ]);
-
-        $validator = new Structure($collection, Database::VAR_INTEGER);
-
-        $base = [
-            '$collection' => ID::custom('posts'),
-            '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
-        ];
-
-        // Multi-byte content over the byte capacity is rejected the same way
-        // (20,000 emoji = 80,000 bytes in utf8mb4).
-        $multibyte = \str_repeat('📝', 20000);
-        $this->assertEquals(false, $validator->isValid(new Document($base + ['text' => $multibyte])));
-    }
-
-    public function testTextByteSafeValidationValid(): void
-    {
-        $collection = new Document([
-            '$id' => ID::custom('posts'),
-            '$collection' => Database::METADATA,
-            'name' => 'posts',
-            'attributes' => [
-                [
-                    '$id' => 'text',
-                    'type' => Database::VAR_TEXT,
-                    'format' => '',
-                    'size' => 1048576,
-                    'required' => false,
-                    'signed' => true,
-                    'array' => false,
-                    'filters' => [],
-                ],
-            ],
-            'indexes' => [],
-        ]);
-
-        $validator = new Structure($collection, Database::VAR_INTEGER);
-
-        $base = [
-            '$collection' => ID::custom('posts'),
-            '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
-        ];
-
-        // A value that fills the column's full byte capacity is accepted.
-        $ok = \str_repeat('a', 65535);
-        $this->assertEquals(true, $validator->isValid(new Document($base + ['text' => $ok])));
-    }
-
-    public function testArrayOfStringsValidation(): void
+    public function test_array_of_strings_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -495,7 +392,7 @@ public function testArrayOfStringsValidation(): void
             'tags' => [1, 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "tags[\'0\']" has invalid type. Value must be a valid string and no longer than 55 chars', $validator->getDescription());
@@ -510,7 +407,7 @@ public function testArrayOfStringsValidation(): void
             'tags' => [true],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "tags[\'0\']" has invalid type. Value must be a valid string and no longer than 55 chars', $validator->getDescription());
@@ -525,7 +422,7 @@ public function testArrayOfStringsValidation(): void
             'tags' => [],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -538,7 +435,7 @@ public function testArrayOfStringsValidation(): void
             'tags' => ['too-long-tag-name-to-make-sure-the-length-validator-inside-string-attribute-type-fails-properly'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "tags[\'0\']" has invalid type. Value must be a valid string and no longer than 55 chars', $validator->getDescription());
@@ -547,11 +444,11 @@ public function testArrayOfStringsValidation(): void
     /**
      * @throws Exception
      */
-    public function testArrayAsObjectValidation(): void
+    public function test_array_as_object_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -564,15 +461,15 @@ public function testArrayAsObjectValidation(): void
             'tags' => ['name' => 'dog'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
     }
 
-    public function testArrayOfObjectsValidation(): void
+    public function test_array_of_objects_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -585,15 +482,15 @@ public function testArrayOfObjectsValidation(): void
             'tags' => [['name' => 'dog']],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
     }
 
-    public function testIntegerValidation(): void
+    public function test_integer_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -606,7 +503,7 @@ public function testIntegerValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "rating" has invalid type. Value must be a valid signed 32-bit integer between -2,147,483,648 and 2,147,483,647', $validator->getDescription());
@@ -621,17 +518,17 @@ public function testIntegerValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "rating" has invalid type. Value must be a valid signed 32-bit integer between -2,147,483,648 and 2,147,483,647', $validator->getDescription());
     }
 
-    public function testArrayOfIntegersValidation(): void
+    public function test_array_of_integers_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -645,7 +542,7 @@ public function testArrayOfIntegersValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -659,7 +556,7 @@ public function testArrayOfIntegersValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -673,7 +570,7 @@ public function testArrayOfIntegersValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -687,17 +584,17 @@ public function testArrayOfIntegersValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "reviews[\'0\']" has invalid type. Value must be a valid signed 32-bit integer between -2,147,483,648 and 2,147,483,647', $validator->getDescription());
     }
 
-    public function testFloatValidation(): void
+    public function test_float_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -710,7 +607,7 @@ public function testFloatValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "price" has invalid type. Value must be a valid float', $validator->getDescription());
@@ -725,17 +622,17 @@ public function testFloatValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "price" has invalid type. Value must be a valid float', $validator->getDescription());
     }
 
-    public function testBooleanValidation(): void
+    public function test_boolean_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -748,7 +645,7 @@ public function testBooleanValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "published" has invalid type. Value must be a valid boolean', $validator->getDescription());
@@ -763,17 +660,17 @@ public function testBooleanValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "published" has invalid type. Value must be a valid boolean', $validator->getDescription());
     }
 
-    public function testFormatValidation(): void
+    public function test_format_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -786,17 +683,17 @@ public function testFormatValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team_appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "feedback" has invalid format. Value must be a valid email address', $validator->getDescription());
     }
 
-    public function testIntegerMaxRange(): void
+    public function test_integer_max_range(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -809,17 +706,17 @@ public function testIntegerMaxRange(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "rating" has invalid type. Value must be a valid signed 32-bit integer between -2,147,483,648 and 2,147,483,647', $validator->getDescription());
     }
 
-    public function testDoubleUnsigned(): void
+    public function test_double_unsigned(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -832,17 +729,17 @@ public function testDoubleUnsigned(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertStringContainsString('Invalid document structure: Attribute "price" has invalid type. Value must be a valid range between 0 and ', $validator->getDescription());
     }
 
-    public function testDoubleMaxRange(): void
+    public function test_double_max_range(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -855,15 +752,15 @@ public function testDoubleMaxRange(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
     }
 
-    public function testId(): void
+    public function test_id(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $sqlId = '1000';
@@ -899,7 +796,7 @@ public function testId(): void
 
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_UUID7
+            ColumnType::Uuid7->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -931,11 +828,11 @@ public function testId(): void
         ])));
     }
 
-    public function testOperatorsSkippedDuringValidation(): void
+    public function test_operators_skipped_during_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         // Operators should be skipped during structure validation
@@ -949,15 +846,15 @@ public function testOperatorsSkippedDuringValidation(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])), $validator->getDescription());
     }
 
-    public function testMultipleOperatorsSkippedDuringValidation(): void
+    public function test_multiple_operators_skipped_during_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         // Multiple operators should all be skipped
@@ -971,15 +868,15 @@ public function testMultipleOperatorsSkippedDuringValidation(): void
             'tags' => Operator::arrayAppend(['new']),
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])), $validator->getDescription());
     }
 
-    public function testMissingRequiredFieldWithoutOperator(): void
+    public function test_missing_required_field_without_operator(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         // Missing required field (not replaced by operator) should still fail
@@ -993,17 +890,17 @@ public function testMissingRequiredFieldWithoutOperator(): void
             'tags' => ['dog', 'cat', 'mouse'],
             'feedback' => 'team@appwrite.io',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Missing required attribute "rating"', $validator->getDescription());
     }
 
-    public function testVarcharValidation(): void
+    public function test_varchar_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -1017,7 +914,7 @@ public function testVarcharValidation(): void
             'feedback' => 'team@appwrite.io',
             'varchar_field' => 'Short varchar text',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -1031,7 +928,7 @@ public function testVarcharValidation(): void
             'feedback' => 'team@appwrite.io',
             'varchar_field' => 123,
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "varchar_field" has invalid type. Value must be a valid string and no longer than 255 chars', $validator->getDescription());
@@ -1047,17 +944,17 @@ public function testVarcharValidation(): void
             'feedback' => 'team@appwrite.io',
             'varchar_field' => \str_repeat('a', 256),
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "varchar_field" has invalid type. Value must be a valid string and no longer than 255 chars', $validator->getDescription());
     }
 
-    public function testTextValidation(): void
+    public function test_text_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -1090,7 +987,7 @@ public function testTextValidation(): void
             'feedback' => 'team@appwrite.io',
             'text_field' => null,
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -1104,7 +1001,7 @@ public function testTextValidation(): void
             'feedback' => 'team@appwrite.io',
             'text_field' => 123,
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "text_field" has invalid type. Value must be a valid string no longer than 65535 bytes', $validator->getDescription());
@@ -1120,17 +1017,17 @@ public function testTextValidation(): void
             'feedback' => 'team@appwrite.io',
             'text_field' => \str_repeat('a', 65536),
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "text_field" has invalid type. Value must be a valid string no longer than 65535 bytes', $validator->getDescription());
     }
 
-    public function testMediumtextValidation(): void
+    public function test_mediumtext_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -1144,7 +1041,7 @@ public function testMediumtextValidation(): void
             'feedback' => 'team@appwrite.io',
             'mediumtext_field' => \str_repeat('a', 100000),
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -1158,7 +1055,7 @@ public function testMediumtextValidation(): void
             'feedback' => 'team@appwrite.io',
             'mediumtext_field' => 123,
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "mediumtext_field" has invalid type. Value must be a valid string no longer than 16777215 bytes', $validator->getDescription());
@@ -1176,7 +1073,7 @@ public function testMediumtextSizedValidation(): void
             'attributes' => [
                 [
                     '$id' => 'mediumtext',
-                    'type' => Database::VAR_MEDIUMTEXT,
+                    'type' => ColumnType::MediumText->value,
                     'format' => '',
                     'size' => 100,
                     'required' => false,
@@ -1188,7 +1085,7 @@ public function testMediumtextSizedValidation(): void
             'indexes' => [],
         ]);
 
-        $validator = new Structure($collection, Database::VAR_INTEGER);
+        $validator = new Structure($collection, ColumnType::Integer->value);
 
         $base = [
             '$collection' => ID::custom('posts'),
@@ -1215,11 +1112,11 @@ public function testMediumtextSizedValidation(): void
         $this->assertEquals('Invalid document structure: Attribute "mediumtext" has invalid type. Value must be a valid string no longer than 100 bytes', $validator->getDescription());
     }
 
-    public function testLongtextValidation(): void
+    public function test_longtext_validation(): void
     {
         $validator = new Structure(
             new Document($this->collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
@@ -1233,7 +1130,7 @@ public function testLongtextValidation(): void
             'feedback' => 'team@appwrite.io',
             'longtext_field' => \str_repeat('a', 1000000),
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
@@ -1247,13 +1144,13 @@ public function testLongtextValidation(): void
             'feedback' => 'team@appwrite.io',
             'longtext_field' => 123,
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "longtext_field" has invalid type. Value must be a valid string no longer than 4294967295 bytes', $validator->getDescription());
     }
 
-    public function testStringTypeArrayValidation(): void
+    public function test_string_type_array_validation(): void
     {
         $collection = [
             '$id' => Database::METADATA,
@@ -1262,7 +1159,7 @@ public function testStringTypeArrayValidation(): void
             'attributes' => [
                 [
                     '$id' => 'varchar_array',
-                    'type' => Database::VAR_VARCHAR,
+                    'type' => ColumnType::Varchar->value,
                     'format' => '',
                     'size' => 128,
                     'required' => false,
@@ -1272,7 +1169,7 @@ public function testStringTypeArrayValidation(): void
                 ],
                 [
                     '$id' => 'text_array',
-                    'type' => Database::VAR_TEXT,
+                    'type' => ColumnType::Text->value,
                     'format' => '',
                     'size' => 65535,
                     'required' => false,
@@ -1286,21 +1183,21 @@ public function testStringTypeArrayValidation(): void
 
         $validator = new Structure(
             new Document($collection),
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
 
         $this->assertEquals(true, $validator->isValid(new Document([
             '$collection' => ID::custom('posts'),
             'varchar_array' => ['test1', 'test2', 'test3'],
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals(false, $validator->isValid(new Document([
             '$collection' => ID::custom('posts'),
             'varchar_array' => [123, 'test2', 'test3'],
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "varchar_array[\'0\']" has invalid type. Value must be a valid string and no longer than 128 chars', $validator->getDescription());
@@ -1309,128 +1206,53 @@ public function testStringTypeArrayValidation(): void
             '$collection' => ID::custom('posts'),
             'varchar_array' => [\str_repeat('a', 129), 'test2'],
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00'
+            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ])));
 
         $this->assertEquals('Invalid document structure: Attribute "varchar_array[\'0\']" has invalid type. Value must be a valid string and no longer than 128 chars', $validator->getDescription());
     }
 
-    public function testBigIntSignedAcceptsNumericStringAndNormalizesToInt(): void
+    public function testLegacyBigIntegerMetadataUsesBigIntegerValidation(): void
     {
-        $collection = [
-            '$id' => Database::METADATA,
+        $collection = new Document([
+            '$id' => ID::custom('posts'),
             '$collection' => Database::METADATA,
-            'name' => 'collections',
+            'name' => 'posts',
             'attributes' => [
                 [
-                    '$id' => 'bigint_signed',
-                    'type' => Database::VAR_BIGINT,
+                    '$id' => 'signed',
+                    'type' => 'bigint',
                     'format' => '',
-                    'size' => 0,
-                    'required' => true,
+                    'size' => 9999,
+                    'required' => false,
                     'signed' => true,
                     'array' => false,
                     'filters' => [],
                 ],
-            ],
-            'indexes' => [],
-        ];
-
-        $validator = new Structure(
-            new Document($collection),
-            Database::VAR_INTEGER
-        );
-
-        $doc = new Document([
-            '$collection' => ID::custom('posts'),
-            'bigint_signed' => (string)PHP_INT_MAX,
-            '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
-        ]);
-
-        $this->assertTrue($validator->isValid($doc));
-        $this->assertIsInt($doc->getAttribute('bigint_signed'));
-        $this->assertEquals(PHP_INT_MAX, $doc->getAttribute('bigint_signed'));
-    }
-
-    public function testBigIntUnsignedAcceptsLargeNumericStringAsString(): void
-    {
-        $collection = [
-            '$id' => Database::METADATA,
-            '$collection' => Database::METADATA,
-            'name' => 'collections',
-            'attributes' => [
                 [
-                    '$id' => 'bigint_unsigned',
-                    'type' => Database::VAR_BIGINT,
+                    '$id' => 'unsigned',
+                    'type' => ColumnType::BigInteger->value,
                     'format' => '',
                     'size' => 0,
-                    'required' => true,
+                    'required' => false,
                     'signed' => false,
                     'array' => false,
                     'filters' => [],
                 ],
             ],
             'indexes' => [],
-        ];
-
-        $validator = new Structure(
-            new Document($collection),
-            Database::VAR_INTEGER
-        );
-
-        $unsignedMax = '18446744073709551615';
-
-        $doc = new Document([
-            '$collection' => ID::custom('posts'),
-            'bigint_unsigned' => $unsignedMax,
-            '$createdAt' => '2000-04-01T12:00:00.000+00:00',
-            '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ]);
-
-        $this->assertTrue($validator->isValid($doc));
-        $this->assertIsString($doc->getAttribute('bigint_unsigned'));
-        $this->assertEquals($unsignedMax, $doc->getAttribute('bigint_unsigned'));
-    }
-
-    public function testBigIntUnsignedRejectsNegativeNumericString(): void
-    {
-        $collection = [
-            '$id' => Database::METADATA,
-            '$collection' => Database::METADATA,
-            'name' => 'collections',
-            'attributes' => [
-                [
-                    '$id' => 'bigint_unsigned',
-                    'type' => Database::VAR_BIGINT,
-                    'format' => '',
-                    'size' => 0,
-                    'required' => true,
-                    'signed' => false,
-                    'array' => false,
-                    'filters' => [],
-                ],
-            ],
-            'indexes' => [],
-        ];
-
-        $validator = new Structure(
-            new Document($collection),
-            Database::VAR_INTEGER
-        );
-
-        $doc = new Document([
+        $validator = new Structure($collection, ColumnType::Integer->value);
+        $document = new Document([
             '$collection' => ID::custom('posts'),
-            'bigint_unsigned' => '-1',
+            'signed' => '-9223372036854775808',
+            'unsigned' => '18446744073709551615',
             '$createdAt' => '2000-04-01T12:00:00.000+00:00',
             '$updatedAt' => '2000-04-01T12:00:00.000+00:00',
         ]);
 
-        $this->assertFalse($validator->isValid($doc));
-        $this->assertEquals(
-            'Invalid document structure: Attribute "bigint_unsigned" has invalid type. Value must be a valid unsigned 64-bit integer between 0 and 18,446,744,073,709,551,615',
-            $validator->getDescription()
-        );
+        $this->assertTrue($validator->isValid($document));
+        $this->assertSame(PHP_INT_MIN, $document->getAttribute('signed'));
+        $this->assertSame('18446744073709551615', $document->getAttribute('unsigned'));
     }
-
 }
diff --git a/tests/unit/Validator/VectorTest.php b/tests/unit/Validator/VectorTest.php
index be98d7ecf2..c57ff9953e 100644
--- a/tests/unit/Validator/VectorTest.php
+++ b/tests/unit/Validator/VectorTest.php
@@ -7,7 +7,7 @@
 
 class VectorTest extends TestCase
 {
-    public function testVector(): void
+    public function test_vector(): void
     {
         // Test valid vectors
         $validator = new Vector(3);
@@ -28,7 +28,7 @@ public function testVector(): void
         $this->assertFalse($validator->isValid([1.0, true, 3.0])); // Boolean value
     }
 
-    public function testVectorWithDifferentDimensions(): void
+    public function test_vector_with_different_dimensions(): void
     {
         $validator1 = new Vector(1);
         $this->assertTrue($validator1->isValid([5.0]));
@@ -46,7 +46,7 @@ public function testVectorWithDifferentDimensions(): void
         $this->assertFalse($validator128->isValid($vector127));
     }
 
-    public function testVectorDescription(): void
+    public function test_vector_description(): void
     {
         $validator = new Vector(3);
         $this->assertEquals('Value must be an array of 3 numeric values', $validator->getDescription());
@@ -55,7 +55,7 @@ public function testVectorDescription(): void
         $this->assertEquals('Value must be an array of 256 numeric values', $validator256->getDescription());
     }
 
-    public function testVectorType(): void
+    public function test_vector_type(): void
     {
         $validator = new Vector(3);
         $this->assertEquals('array', $validator->getType());
diff --git a/tests/unit/Vector/VectorValidationTest.php b/tests/unit/Vector/VectorValidationTest.php
new file mode 100644
index 0000000000..958d461c0f
--- /dev/null
+++ b/tests/unit/Vector/VectorValidationTest.php
@@ -0,0 +1,468 @@
+<?php
+
+namespace Tests\Unit\Vector;
+
+use DateTime;
+use PHPUnit\Framework\MockObject\Stub;
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Adapter\None;
+use Utopia\Cache\Cache;
+use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
+use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
+
+class VectorValidationTest extends TestCase
+{
+    private Adapter&Stub $adapter;
+
+    private Database $database;
+
+    protected function setUp(): void
+    {
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getSharedTables')->willReturn(false);
+        $this->adapter->method('getTenant')->willReturn(null);
+        $this->adapter->method('getTenantPerDocument')->willReturn(false);
+        $this->adapter->method('getNamespace')->willReturn('');
+        $this->adapter->method('getIdAttributeType')->willReturn('string');
+        $this->adapter->method('getMaxUIDLength')->willReturn(36);
+        $this->adapter->method('getMinDateTime')->willReturn(new DateTime('0000-01-01'));
+        $this->adapter->method('getMaxDateTime')->willReturn(new DateTime('9999-12-31'));
+        $this->adapter->method('getLimitForString')->willReturn(16777215);
+        $this->adapter->method('getLimitForInt')->willReturn(2147483647);
+        $this->adapter->method('getLimitForAttributes')->willReturn(0);
+        $this->adapter->method('getLimitForIndexes')->willReturn(64);
+        $this->adapter->method('getMaxIndexLength')->willReturn(768);
+        $this->adapter->method('getMaxVarcharLength')->willReturn(16383);
+        $this->adapter->method('getDocumentSizeLimit')->willReturn(0);
+        $this->adapter->method('getCountOfAttributes')->willReturn(0);
+        $this->adapter->method('getCountOfIndexes')->willReturn(0);
+        $this->adapter->method('getAttributeWidth')->willReturn(0);
+        $this->adapter->method('getInternalIndexesKeys')->willReturn([]);
+        $this->adapter->method('filter')->willReturnArgument(0);
+        $this->adapter->method('supports')->willReturnCallback(function (Capability $cap) {
+            return in_array($cap, [
+                Capability::Index,
+                Capability::IndexArray,
+                Capability::UniqueIndex,
+                Capability::DefinedAttributes,
+                Capability::Vectors,
+            ]);
+        });
+        $this->adapter->method('startTransaction')->willReturn(true);
+        $this->adapter->method('commitTransaction')->willReturn(true);
+        $this->adapter->method('rollbackTransaction')->willReturn(true);
+        $this->adapter->method('withTransaction')->willReturnCallback(function (callable $callback) {
+            return $callback();
+        });
+        $this->adapter->method('createAttribute')->willReturn(true);
+        $this->adapter->method('createIndex')->willReturn(true);
+        $this->adapter->method('deleteIndex')->willReturn(true);
+        $this->adapter->method('createDocument')->willReturnArgument(1);
+        $this->adapter->method('updateDocument')->willReturnArgument(2);
+        $this->adapter->method('find')->willReturn([]);
+        $this->adapter->method('getSequences')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function metaCollection(): Document
+    {
+        return new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [Permission::read(Role::any()), Permission::create(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())],
+            '$version' => 1,
+            'name' => 'collections',
+            'attributes' => [
+                new Document(['$id' => 'name', 'key' => 'name', 'type' => 'string', 'size' => 256, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+                new Document(['$id' => 'attributes', 'key' => 'attributes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'indexes', 'key' => 'indexes', 'type' => 'string', 'size' => 1000000, 'required' => false, 'signed' => true, 'array' => false, 'filters' => ['json']]),
+                new Document(['$id' => 'documentSecurity', 'key' => 'documentSecurity', 'type' => 'boolean', 'size' => 0, 'required' => true, 'signed' => true, 'array' => false, 'filters' => []]),
+            ],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $attributes
+     * @param  array<int, Document>  $indexes
+     */
+    private function makeCollection(string $id, array $attributes = [], array $indexes = []): Document
+    {
+        return new Document([
+            '$id' => $id,
+            '$sequence' => $id,
+            '$collection' => Database::METADATA,
+            '$createdAt' => '2024-01-01T00:00:00.000+00:00',
+            '$updatedAt' => '2024-01-01T00:00:00.000+00:00',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            '$version' => 1,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => true,
+        ]);
+    }
+
+    /**
+     * @param  array<int, Document>  $collections
+     */
+    private function setupCollections(array $collections): void
+    {
+        $meta = $this->metaCollection();
+        $map = [];
+        foreach ($collections as $col) {
+            $map[$col->getId()] = $col;
+        }
+
+        $this->adapter->method('getDocument')->willReturnCallback(
+            function (Document $col, string $docId) use ($meta, $map) {
+                if ($col->getId() === Database::METADATA && $docId === Database::METADATA) {
+                    return $meta;
+                }
+                if ($col->getId() === Database::METADATA && isset($map[$docId])) {
+                    return $map[$docId];
+                }
+
+                return new Document();
+            }
+        );
+    }
+
+    /**
+     * @param  array<int, Document>  $extraAttrs
+     */
+    private function vectorCollection(string $id, int $dimensions = 3, bool $required = true, array $extraAttrs = []): Document
+    {
+        $attrs = [
+            new Document([
+                '$id' => 'embedding', 'key' => 'embedding',
+                'type' => ColumnType::Vector->value,
+                'size' => $dimensions, 'required' => $required, 'default' => null,
+                'signed' => true, 'array' => false, 'filters' => [],
+            ]),
+            ...$extraAttrs,
+        ];
+
+        return $this->makeCollection($id, $attrs);
+    }
+
+    public function testVectorInvalidDimensions(): void
+    {
+        $col = $this->makeCollection('vectorError');
+        $this->setupCollections([$col]);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Vector dimensions must be a positive integer');
+
+        $this->database->createAttribute('vectorError', Attribute::vector(key: 'bad_embedding', required: true));
+    }
+
+    public function testVectorTooManyDimensions(): void
+    {
+        $col = $this->makeCollection('vectorLimit');
+        $this->setupCollections([$col]);
+
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Vector dimensions cannot exceed 16000');
+
+        $this->database->createAttribute('vectorLimit', Attribute::vector(key: 'huge_embedding', size: 16001, required: true));
+    }
+
+    public function testVectorQueryValidation(): void
+    {
+        $textAttr = new Document([
+            '$id' => 'name', 'key' => 'name',
+            'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->vectorCollection('vectorValidation', 3, true, [$textAttr]);
+        $this->setupCollections([$col]);
+
+        $this->expectException(DatabaseException::class);
+
+        $this->database->find('vectorValidation', [
+            Query::vectorDot('name', [1.0, 0.0, 0.0]),
+        ]);
+    }
+
+    public function testVectorDimensionMismatch(): void
+    {
+        $col = $this->vectorCollection('vectorDimMismatch');
+        $this->setupCollections([$col]);
+
+        $this->expectException(DatabaseException::class);
+
+        $this->database->createDocument('vectorDimMismatch', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'embedding' => [1.0, 0.0],
+        ]));
+    }
+
+    public function testVectorWithInvalidDataTypes(): void
+    {
+        $col = $this->vectorCollection('vectorInvalidTypes');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorInvalidTypes', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => ['one', 'two', 'three'],
+            ]));
+            $this->fail('Should have thrown exception for non-numeric vector values');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric values', strtolower($e->getMessage()));
+        }
+
+        try {
+            $this->database->createDocument('vectorInvalidTypes', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => [1.0, 'two', 3.0],
+            ]));
+            $this->fail('Should have thrown exception for mixed type vector values');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric values', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorQueryValidationExtended(): void
+    {
+        $textAttr = new Document([
+            '$id' => 'text', 'key' => 'text',
+            'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->vectorCollection('vectorValidation2', 3, true, [$textAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->find('vectorValidation2', [
+                Query::vectorCosine('embedding', [1.0, 0.0]),
+            ]);
+            $this->fail('Should have thrown exception for dimension mismatch');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('elements', strtolower($e->getMessage()));
+        }
+
+        try {
+            $this->database->find('vectorValidation2', [
+                Query::vectorCosine('text', [1.0, 0.0, 0.0]),
+            ]);
+            $this->fail('Should have thrown exception for non-vector attribute');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('vector', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorWithAssociativeArray(): void
+    {
+        $col = $this->vectorCollection('vectorAssoc');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorAssoc', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => ['x' => 1.0, 'y' => 0.0, 'z' => 0.0],
+            ]));
+            $this->fail('Should have thrown exception for associative array');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorWithSparseArray(): void
+    {
+        $col = $this->vectorCollection('vectorSparse');
+        $this->setupCollections([$col]);
+
+        try {
+            $vector = [];
+            $vector[0] = 1.0;
+            $vector[2] = 1.0;
+            $this->database->createDocument('vectorSparse', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => $vector,
+            ]));
+            $this->fail('Should have thrown exception for sparse array');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorWithNestedArrays(): void
+    {
+        $col = $this->vectorCollection('vectorNested');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorNested', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => [[1.0], [0.0], [0.0]],
+            ]));
+            $this->fail('Should have thrown exception for nested array');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorWithBooleansInArray(): void
+    {
+        $col = $this->vectorCollection('vectorBooleans');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorBooleans', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => [true, false, true],
+            ]));
+            $this->fail('Should have thrown exception for boolean values');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorWithStringNumbers(): void
+    {
+        $col = $this->vectorCollection('vectorStringNums');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorStringNums', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => ['1.0', '2.0', '3.0'],
+            ]));
+            $this->fail('Should have thrown exception for string numbers');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorCosineSimilarityDivisionByZero(): void
+    {
+        $col = $this->vectorCollection('vectorCosineZero');
+        $this->setupCollections([$col]);
+
+        $doc = $this->database->createDocument('vectorCosineZero', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'embedding' => [0.0, 0.0, 0.0],
+        ]));
+
+        $this->assertNotSame('', $doc->getId());
+    }
+
+    public function testVectorSearchWithRestrictedPermissions(): void
+    {
+        $col = $this->vectorCollection('vectorPermissions');
+        $this->setupCollections([$col]);
+
+        $doc = $this->database->createDocument('vectorPermissions', new Document([
+            '$permissions' => [Permission::read(Role::user('user1'))],
+            'embedding' => [1.0, 0.0, 0.0],
+        ]));
+
+        $this->assertNotSame('', $doc->getId());
+    }
+
+    public function testVectorPermissionFilteringAfterScoring(): void
+    {
+        $scoreAttr = new Document([
+            '$id' => 'score', 'key' => 'score',
+            'type' => ColumnType::Integer->value,
+            'size' => 0, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->vectorCollection('vectorPermScoring', 3, true, [$scoreAttr]);
+        $this->setupCollections([$col]);
+
+        $doc = $this->database->createDocument('vectorPermScoring', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'score' => 4,
+            'embedding' => [0.6, 0.4, 0.0],
+        ]));
+
+        $this->assertNotSame('', $doc->getId());
+    }
+
+    public function testVectorRequiredWithNullValue(): void
+    {
+        $col = $this->vectorCollection('vectorRequiredNull', 3, true);
+        $this->setupCollections([$col]);
+
+        $this->expectException(DatabaseException::class);
+
+        $this->database->createDocument('vectorRequiredNull', new Document([
+            '$permissions' => [Permission::read(Role::any())],
+            'embedding' => null,
+        ]));
+    }
+
+    public function testVectorIndexCreationFailure(): void
+    {
+        $textAttr = new Document([
+            '$id' => 'text', 'key' => 'text',
+            'type' => ColumnType::String->value,
+            'size' => 255, 'required' => true, 'default' => null,
+            'signed' => true, 'array' => false, 'filters' => [],
+        ]);
+
+        $col = $this->vectorCollection('vectorIdxFail', 3, true, [$textAttr]);
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createIndex('vectorIdxFail', Index::hnswCosine(key: 'bad_idx', attributes: ['text']));
+            $this->fail('Should not allow vector index on non-vector attribute');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('vector', strtolower($e->getMessage()));
+        }
+    }
+
+    public function testVectorNonNumericValidationE2E(): void
+    {
+        $col = $this->vectorCollection('vectorNonNumeric');
+        $this->setupCollections([$col]);
+
+        try {
+            $this->database->createDocument('vectorNonNumeric', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => [1.0, null, 0.0],
+            ]));
+            $this->fail('Should reject null in vector array');
+        } catch (DatabaseException $e) {
+            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
+        }
+
+        try {
+            $this->database->createDocument('vectorNonNumeric', new Document([
+                '$permissions' => [Permission::read(Role::any())],
+                'embedding' => [1.0, (object) ['x' => 1], 0.0],
+            ]));
+            $this->fail('Should reject object in vector array');
+        } catch (\Throwable $e) {
+            $this->assertNotSame('', $e->getMessage());
+        }
+    }
+}
diff --git a/tests/unit/WithCacheLeaseTest.php b/tests/unit/WithCacheLeaseTest.php
index 8eafd3540c..be2f6f5622 100644
--- a/tests/unit/WithCacheLeaseTest.php
+++ b/tests/unit/WithCacheLeaseTest.php
@@ -7,6 +7,8 @@
 use Utopia\Cache\Cache;
 use Utopia\Cache\Feature\Leasable;
 use Utopia\Database\Adapter\Memory as DatabaseMemory;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\Permission;
@@ -29,8 +31,8 @@ protected function setUp(): void
             ->setNamespace('with_cache_' . \uniqid());
 
         $this->database->create();
-        $this->database->createCollection('projects');
-        $this->database->createAttribute('projects', 'name', Database::VAR_STRING, 255, false);
+        $this->database->createCollection(new Collection(id: 'projects'));
+        $this->database->createAttribute('projects', Attribute::string(key: 'name'));
         $this->database->createDocument('projects', new Document([
             '$id' => 'project',
             '$permissions' => [
@@ -52,17 +54,24 @@ public function testStaleListWriteAfterConcurrentPurgeIsRejected(): void
         // concurrent writer purges the query key after the read started but
         // before the result is cached. Without a lease the stale list below
         // would land in the cache after the purge.
-        $result = $this->database->withCache($this->key, function () use ($hash, $document) {
-            $this->cacheAdapter->purge($this->key, $hash);
+        $result = $this->database->withCache($this->key, function () use ($document) {
+            $this->database->purgeCachedQueries('projects');
 
             return [$document];
         }, $hash);
 
+        /** @var mixed $result */
+        $this->assertIsArray($result);
         $this->assertCount(1, $result);
-        $this->assertFalse(
-            $this->cacheAdapter->load($this->key, Database::TTL, $hash),
-            'A list read whose query key was purged mid-flight must not be re-cached.'
-        );
+        $callbackCalls = 0;
+        $fresh = $this->database->withCache($this->key, function () use (&$callbackCalls): array {
+            $callbackCalls++;
+
+            return [];
+        }, $hash);
+        /** @var mixed $fresh */
+        $this->assertSame([], $fresh);
+        $this->assertSame(1, $callbackCalls);
     }
 
     public function testListWriteLandsWhenNoConcurrentPurge(): void
@@ -73,11 +82,19 @@ public function testListWriteLandsWhenNoConcurrentPurge(): void
 
         $result = $this->database->withCache($this->key, fn () => [$document], $hash);
 
+        /** @var mixed $result */
+        $this->assertIsArray($result);
         $this->assertCount(1, $result);
-        $this->assertNotFalse(
-            $this->cacheAdapter->load($this->key, Database::TTL, $hash),
-            'A list read with no concurrent purge must populate the cache.'
-        );
+        $callbackCalls = 0;
+        $cached = $this->database->withCache($this->key, function () use (&$callbackCalls): array {
+            $callbackCalls++;
+
+            return [];
+        }, $hash);
+        /** @var mixed $cached */
+        $this->assertIsArray($cached);
+        $this->assertCount(1, $cached);
+        $this->assertSame(0, $callbackCalls);
     }
 }
 
@@ -86,7 +103,7 @@ class LeasableMemoryCache implements Adapter, Leasable
     private const string GENERATION_FIELD = '__utopia_gen__';
 
     /**
-     * @var array<string, array<string, mixed>>
+     * @var array<string, array<string, array{time: int, data: array<int|string, mixed>|string}>>
      */
     private array $store = [];
 
@@ -126,7 +143,9 @@ public function save(string $key, array|string $data, string $hash = ''): bool|s
 
     public function getGeneration(string $key): string
     {
-        return $this->store[$key][self::GENERATION_FIELD]['data'] ?? '0';
+        $generation = $this->store[$key][self::GENERATION_FIELD]['data'] ?? '0';
+
+        return \is_string($generation) ? $generation : '0';
     }
 
     public function saveWithLease(string $key, array|string $data, string $hash, string $generation): bool|string|array